* MAINMEM.SHR.S
* (c) Bobbi 2022 GPLv3
*
* Routines for drawing bitmapped text and graphics in SHR mode
* on Apple IIGS (640x200 4 colour, or 320x200 16 colour.)
*
* This code is in main memory only to save space in aux LC.
*

******************************************************************************
* Data in bank $E1
******************************************************************************

SHRFONTXPLD   EQU   $A000                  ; Explode SHR font to $E1:A000

******************************************************************************

* 21 bytes of persistent storage, also accessed by mainmem code
* TODO: Move to SHRZP maybe
SHRPIXELS     DB    $00                    ; Main memory copy of VDUPIXELS
SHRVDUQ       DS    16                     ; Main memory copy of VDUQ
SHRGFXFGMASK  DB    $00                    ; Foreground colour mask
SHRGFXFGMSK2  DB    $00                    ; Copy of foreground colour mask
SHRGFXBGMASK  DB    $00                    ; Background colour mask
SHRGFXACTION  DB    $00                    ; GCOL action for point plotting

* These are all persistent locals (14 bytes of ZP)
SHRXPIXEL     EQU   SHRZP+0                ; Prev point in screen coords (word)
SHRYPIXEL     EQU   SHRZP+2                ; Prev point in screen coords (word)
SHRWINLFT     EQU   SHRZP+4                ; Gfx win - left (0-639) (word)
SHRWINRGT     EQU   SHRZP+6                ; Gfx win - right (0-639) (word)
SHRWINTOP     EQU   SHRZP+8                ; Gfx win - top (0-199) (word)
SHRWINBTM     EQU   SHRZP+10               ; Gfx win - bottom (0-199) (word)


* Colours in the following order.
* For 16 colour modes ...
* BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, ...
* For 4 colour modes ...
* BLACK, RED, YELLOW, WHITE

*                    GB   0R
PALETTE320    DB    $00, $00               ; BLACK
              DB    $00, $0F               ; RED
              DB    $F0, $00               ; GREEN
              DB    $F0, $0F               ; YELLOW
              DB    $0F, $00               ; BLUE
              DB    $0F, $0F               ; MAGENTA
              DB    $FF, $00               ; CYAN
              DB    $FF, $0F               ; WHITE
              DB    $44, $04               ; Dark grey
              DB    $88, $0F               ; RED (light)
              DB    $F8, $08               ; GREEN (light)
              DB    $F8, $0F               ; YELLOW (light)
              DB    $8F, $08               ; BLUE (light)
              DB    $8F, $0F               ; MAGENTA (light)
              DB    $FF, $08               ; CYAN (light)
              DB    $AA, $0A               ; Light grey

PALETTE640    DB    $00, $00               ; BLACK
              DB    $00, $0F               ; RED
              DB    $F0, $0F               ; YELLOW
              DB    $FF, $0F               ; WHITE
              DB    $00, $00               ; BLACK
              DB    $00, $0F               ; RED
              DB    $F0, $0F               ; YELLOW
              DB    $F8, $0F               ; WHITE
              DB    $00, $00               ; BLACK
              DB    $00, $0F               ; RED
              DB    $F0, $0F               ; YELLOW
              DB    $FF, $0F               ; WHITE
              DB    $00, $00               ; BLACK
              DB    $00, $0F               ; RED
              DB    $F0, $0F               ; YELLOW
              DB    $FF, $0F               ; WHITE


* Explode font to generate SHRFONTXPLD table
* This is 2 bytes x 8 rows for each character in 640 mode
* or      4 bytes x 8 rows for each character in 320 mode
SHRXPLDFONT   >>>   ENTMAIN
              LDA   #<SHRFONTXPLD          ; Use A3L/H to point to ..
              STA   A3L                    ; .. start of table to write
              LDA   #>SHRFONTXPLD
              STA   A3H
              LDA   #$E1                   ; Memory bank $E1
              STA   A4L
              LDA   #32                    ; First char number
:L1           JSR   SHRXPLDCHAR            ; Explode char A
              INC   A
              CMP   #128                   ; 96 chars in FONT8
              BNE   :L1
              JSR   SHRCLR24               ; Clear row 24
              >>>   XF2AUX,SHRV22RET


* Explode one character to location pointed to by A3L
* On entry: A - character to explode
SHRXPLDCHAR   PHA
              SEC
              SBC   #32
              STA   A1L                    ; A*8 -> A1L/H
              STZ   A1H
              ASL   A1L
              ROL   A1H
              ASL   A1L
              ROL   A1H
              ASL   A1L
              ROL   A1H
              CLC                          ; FONT8+A*8 -> A1L/H
              LDA   A1L
              ADC   #<FONT8
              STA   A1L
              LDA   A1H
              ADC   #>FONT8
              STA   A1H
              LDY   #$00                   ; First row of char
:L1           LDA   (A1L),Y                ; Load row of font
              JSR   SHRXPLDROW
              INY                          ; Next row of font
              CPY   #$08                   ; Last row?
              BNE   :L1
              PLA
              RTS


* Explode one pixel row of user defined graphics char
SHRUSERCHAR   >>>   ENTMAIN
              LDA   #<SHRFONTXPLD          ; Use A3L/H to point to ..
              STA   A3L                    ; .. start of table to write
              LDA   #>SHRFONTXPLD
              STA   A3H
              LDA   #$E1                   ; Bank $E1
              STA   A4L

              LDA   SHRVDUQ+0              ; Character number
              CMP   #32                    ; < 32? Then bail out
              BCC   :DONE
              SEC                          ; Otherwise, subtract 32
              SBC   #32
              TAY

              LDA   #16                    ; Bytes/char in 640 mode              
              LDX   SHRPIXELS              ; Pixels per byte
              CPX   #$02                   ; 2 is 320-mode (MODE 1)
              BNE   :S0
              LDA   #32                    ; Bytes/char in 320 mode
:S0           STA   :INCREMENT

:L0           CPY   #$00
              BEQ   :S1
              CLC
              LDA   A3L
              ADC   :INCREMENT
              STA   A3L
              LDA   A3H
              ADC   #$00
              STA   A3H
              DEY
              BRA   :L0

:S1           LDY   #$00
:L1           LDA   SHRVDUQ+1,Y            ; Row of pixels
              JSR   SHRXPLDROW
              INY
              CPY   #$08                   ; Last row?
              BNE   :L1
:DONE         >>>   XF2AUX,VDUXXRET
:INCREMENT    DB    $00


* Explode one row of pixels. Used by SHRXPLDCHAR & SHRUSERCHAR
* On entry: A contains row of font data
SHRXPLDROW    LDX   SHRPIXELS              ; Pixels per byte
              CPX   #$02                   ; 2 is 320-mode (MODE 1)
              BNE   :S1
              JSR   SHRCHAR320
              BRA   :S2
:S1           JSR   SHRCHAR640
:S2           LDX   SHRPIXELS              ; Pixels per byte
              CPX   #$02                   ; 2 is 320-mode (MODE 1)
              BNE   :S3
              CLC                          ; 320 mode: add 4 to A3L
              LDA   A3L
              ADC   #$04
              STA   A3L
              LDA   A3H
              ADC   #$00
              STA   A3H
              BRA   :S4
:S3           CLC                          ; 640 mode: add 2 to A3L
              LDA   A3L
              ADC   #$02
              STA   A3L
              LDA   A3H
              ADC   #$00
              STA   A3H
:S4           RTS


* Clear text row 24 (0-based index)
SHRCLR24      CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDX   #$00
              LDA   #$00
:L1           STAL  $E19800,X
              INX
              INX
              CPX   #$0500
              BNE   :L1
              SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin
              RTS


* Explode one pixel row of font in 320 mode
* 4 bytes per char, 4 bits per pixel
* On entry: A contains row of font data
SHRCHAR320    PHY                          ; Preserve Y
              LDY   #$00                   ; Dest byte index
:L0           STZ   A2L
              LDX   #$00                   ; Source bit index
:L1           ASL                          ; MS bit -> C
              PHP                          ; Preserve C
              ROL   A2L                    ; C -> LS bit
              PLP                          ; Recover C
              PHP
              ROL   A2L                    ; C -> LS bit
              PLP                          ; Recover C
              PHP
              ROL   A2L                    ; C -> LS bit
              PLP                          ; Recover C
              ROL   A2L                    ; C -> LS bit
              INX
              CPX   #$02                   ; Processed two bits of font?
              BNE   :L1
              PHA                          ; Preserve partially shifted font
              LDA   A2L
              STA   [A3L],Y
              PLA                          ; Recover partially shifted font
              INY
              CPY   #$04                   ; Done 4 bytes?
              BNE   :L0
              PLY                          ; Recover Y
              RTS


* Explode one pixel row of font in 640 mode
* 2 bytes per char, 2 bits per pixel
* On entry: A contains row of font data
SHRCHAR640    PHY                          ; Preserve Y
              LDY   #$00                   ; Dest byte index
:L0           STZ   A2L
              LDX   #$00                   ; Source bit index
:L1           ASL                          ; MS bit -> C
              PHP                          ; Preserve C
              ROL   A2L                    ; C -> LS bit
              PLP                          ; Recover C
              ROL   A2L                    ; C -> LS bit
              INX
              CPX   #$04
              BNE   :L1
              PHA                          ; Preserve partially shifted font
              LDA   A2L
              STA   [A3L],Y
              PLA                          ; Recover partially shifted font
              INY
              CPY   #$02                   ; Done 2 bytes?
              BNE   :L0
              PLY                          ; Recover Y
              RTS


* Handle plotting & unplotting cursors
* On entry: character in A, flags in Y
*           pointer to screen address in SHRVDUQ+0..1
SHRCURSM      >>>   ENTMAIN
              PHY                          ; Preserve flags
              PHA                          ; Preserve character
              LDA   SHRVDUQ+0              ; Copy pointer to A3L/H
              STA   A3L
              LDA   SHRVDUQ+1
              STA   A3H
              LDA   #$E1                   ; Bank $E1
              STA   A4L
              LDA   SHRPIXELS              ; Pixels per byte
              CMP   #$02                   ; 2 is 320-mode (MODE 1)
              BNE   :MODE0
              LDA   #$04                   ; 4 bytes in 320 mode
              LDX   #$71                   ; White/red
              BRA   :S1
:MODE0        LDA   #$02                   ; 2 bytes in 640 mode
              LDX   #%11011101             ; White/red/white/red
:S1           STA   :BYTES                 ; Bytes per char
              STX   :CURSBYTE
              LDA   A3L                    ; LSB
              CLC
              ADC   #<$460                 ; $460 is seven rows
              STA   A3L
              LDA   A3H                    ; MSB
              ADC   #>$460                 ; $460 is seven rows
              STA   A3H
              LDY   #$00
              LDX   #$00
              PLA                          ; Recover character
              PLP                          ; Recover flags
              BVC   :S2                    ; VC: Write cursor
              INX                          ; Advance to 2nd half of :SAVEBYTES
              INX
              INX
              INX
:S2           BCC   :CURSOROFF             ; CC: Remove cursor
:CURSORON
              LDAL  [A3L],Y                ; See if cursor shown
              CMP   :CURSBYTE
              BEQ   :DONE                  ; Cursor shown already, skip
:L1           LDAL  [A3L],Y
              STA   :SAVEBYTES,X           ; Preserve bytes under cursor
              LDA   :CURSBYTE              ; Byte of cursor data
              STAL  [A3L],Y
              INX
              INY
              CPY   :BYTES
              BNE   :L1
              >>>   XF2AUX,SHRCURSRET
:CURSOROFF
              LDAL  [A3L],Y                ; See if cursor shown
              CMP   :CURSBYTE
              BNE   :DONE                  ; Cursor not shown, skip
:L2           LDA   :SAVEBYTES,X           ; Restore bytes under cursor
              STAL  [A3L],Y
              INX
              INY
              CPY   :BYTES
              BNE   :L2
:DONE         >>>   XF2AUX,SHRCURSRET
:BYTES        DB    $00                    ; 2 for 640-mode, 4 for 320-mode
:CURSBYTE     DB    $00                    ; Cursor byte for mode
:SAVEBYTES    DS    8                      ; Bytes under cursors


* VDU5 plot char at graphics cursor position
SHRVDU5CH     >>>   ENTMAIN
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin

              AND   #$00FF
              STA   A1L                    ; A*16 -> A1L/H
              ASL   A1L
              ASL   A1L
              ASL   A1L
              ASL   A1L

              LDA   SHRPIXELS              ; Pixels per byte
              AND   #$00FF
              CMP   #$02                   ; 2 is 320-mode (MODE 1)
              BNE   :MODE0
              LDA   #$04                   ; 4 bytes per row in MODE 1
              ASL   A1L                    ; A*32 -> A1L/H in MODE 1
              BRA   :S0
:MODE0        LDA   #$02                   ; 2 bytes per row in MODE 0
:S0           STA   :BYTES

              CLC                          ; Add SHRFONTXPLD to A1L/H
              LDA   A1L
              ADC   #SHRFONTXPLD
              STA   A1L

              LDA   SHRYPIXEL              ; y coordinate
              SEC
              SBC   #8                     ; Height of this row
              CMP   SHRWINBTM
              BMI   :NEWPAGE
              LDA   SHRYPIXEL
              CMP   SHRWINTOP
              BEQ   :S1
              BPL   :NEWPAGE
:S1           LDA   SHRXPIXEL              ; x coordinate
              CMP   SHRWINLFT
              BMI   :NEWPAGE
              CMP   SHRWINRGT
              BEQ   :S2
              BPL   :NEWPAGE
              BRA   :S2
:NEWPAGE      LDA   SHRWINTOP
              STA   SHRYPIXEL
              LDA   SHRWINLFT
              STA   SHRXPIXEL

:S2           SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin
              LDX   SHRYPIXEL              ; Screen row (Y-coord)
              LDA   SHRROWSL,X             ; Look up addr (LS byte)
              STA   A3L                    ; Stash in A3L
              LDA   SHRROWSH,X             ; Look up addr (MS byte)
              STA   A3H                    ; Stash in A3H
              LDA   #$E1                   ; Bank $E1
              STA   A4L
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin

              LDX   SHRXPIXEL              ; Screen col (X-coord)
              STX   A2L
              LSR   A2L                    ; Divide by 2

              LDA   SHRPIXELS
              AND   #$00FF
              CMP   #$02
              BEQ   :M1                    ; MODE 1
              LSR   A2L                    ; Divide by 2 again
:M1           LDX   A1L                    ; Index into exploded font
              STZ   :ROWCTR
:L0           
              PHX
              LDY   #$00
              STZ   :PIXBUF+2              ; Clear bytes 3,4 of shift buf
              STZ   :PIXBUF+4              ; Clear bytes 5,6 of shift buf
:LOOP         LDAL  $E10000,X              ; Read a word of exploded font
              STA   :PIXBUF,Y              ; Store word to shift buffer
              INX
              INX
              INY
              INY
              CPY   :BYTES
              BNE   :LOOP
              LDA   SHRXPIXEL
              JSR   SHRSHIFT               ; Shift :PIXBUF to the right
              LDY   A2L                    ; Index into row of pixels
              STZ   :COLCTR
              LDX   #$00
              INC   :BYTES
:L1           LDA   :PIXBUF,X              ; Read word of exploded font
              PHX
              SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin
              JSR   SHRPLOTBYTE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              PLX
              INX                          ; Next byte of font
              INY                          ; Next byte on screen
              INC   :COLCTR
              LDA   :COLCTR
              CMP   :BYTES                 ; Bytes per row 
              BNE   :L1
              DEC   :BYTES

              PLA                          ; Restore saved X -> A
              CLC                          ; Add bytes per row
              ADC   :BYTES
              TAX                          ; Back to X

              LDA   A3L                    ; Increment A3L/H to next row
              CLC
              ADC   #$A0
              STA   A3L
              LDA   A3H
              ADC   #$00
              STA   A3H
              INC   :ROWCTR
              LDA   :ROWCTR
              CMP   #$08                   ; 8 rows
              BNE   :L0
:DONE         SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin
              >>>   XF2AUX,SHRPRCH320RET
* Zero page
:COLCTR       EQU   TMPZP+0
:ROWCTR       EQU   TMPZP+2
:BYTES        EQU   TMPZP+4                ; Bytes per char row
:PIXBUF       EQU   TMPZP+6                ; Shift buffer (6 bytes)


* Shifts one character row of pixels to the right
* Called in 65816 native mode, 16 bit M & X
* On entry: A - x-coordinate of char
SHRSHIFT      MX    %00                    ; Tell merlin we are 16 bit M&X
              PHA
              LDA   SHRPIXELS              ; Pixels per byte
              AND   #$00FF
              CMP   #$02                   ; 2 is 320-mode (MODE 1)
              BNE   :MODE0
              PLA
              AND   #$0001                 ; Bits to shift in MODE 1
              ASL
              PHA
:MODE0        PLA
              AND   #$0003                 ; Bits to shift in MODE 0
              PHA

              LDA   :PIXBUF                ; Put bytes in big-endian order
              XBA
              STA   :PIXBUF
              LDA   :PIXBUF+2
              XBA
              STA   :PIXBUF+2
              LDA   :PIXBUF+4
              XBA
              STA   :PIXBUF+4

              PLA
:L1           CMP   #$0000
              BEQ   :S1
              LSR   :PIXBUF                ; Shift :PIXBUF to the right 1 bit
              ROR   :PIXBUF+2
              ROR   :PIXBUF+4
              LSR   :PIXBUF                ; Shift right again
              ROR   :PIXBUF+2
              ROR   :PIXBUF+4
              DEC   A
              BRA   :L1

:S1           LDA   :PIXBUF                ; Put bytes back in little-endian
              XBA
              STA   :PIXBUF
              LDA   :PIXBUF+2
              XBA
              STA   :PIXBUF+2
              LDA   :PIXBUF+4
              XBA
              STA   :PIXBUF+4
              RTS
              MX    %11


* Handle cursor left in VDU5 mode
SHRVDU08      >>>   ENTMAIN
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDA   SHRXPIXEL
              SEC
              SBC   #$08                   ; Move to previous column
              CMP   SHRWINLFT
              BMI   :PREVLINE              ; x-pos < SHRWINLFT
              STA   SHRXPIXEL
              BRA   :DONE
:PREVLINE     LDA   SHRYPIXEL
              CLC                          ; Add 8 rows (go up)
              ADC   #$08
              CMP   SHRWINTOP
              BCS   :HOME                  ; y-pos >= SHRWINTOP
              STA   SHRYPIXEL
              LDA   SHRWINRGT
              SEC
              SBC   #$07
              STA   SHRXPIXEL
              BRA   :DONE
:HOME         LDA   SHRWINTOP
              STA   SHRYPIXEL
              LDA   SHRWINLFT
              STA   SHRXPIXEL
:DONE         SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin
              >>>   XF2AUX,VDUXXRET


* Handle cursor right in VDU5 mode
SHRVDU09      >>>   ENTMAIN
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDA   SHRXPIXEL
              CLC
              ADC   #$08                   ; Advance to next column
              CMP   SHRWINRGT
              BCS   :NEWLINE               ; x-pos >= SHRWINRGT
              STA   SHRXPIXEL
              BRA   :DONE
:NEWLINE      LDA   SHRWINLFT
              STA   SHRXPIXEL
              JSR   SHRVDU5LF
:DONE         SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin
              >>>   XF2AUX,VDUXXRET


* Handle cursor down / linefeed in VDU5 mode
SHRVDU10      >>>   ENTMAIN
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              JSR   SHRVDU5LF
:DONE         SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin
              >>>   XF2AUX,VDUXXRET


* Handle cursor up in VDU5 mode
SHRVDU11      >>>   ENTMAIN
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDA   SHRYPIXEL
              CLC
              ADC   #$08                   ; Height of row of text
              CMP   SHRWINTOP
              BCS   :TOP                   ; y-pos >= SHRWINTOP
              STA   SHRYPIXEL
              BRA   :DONE
:TOP          LDA   SHRWINTOP
              STA   SHRYPIXEL
:DONE         SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin
              >>>   XF2AUX,VDUXXRET


* Handle linefeed in VDU5 mode - does the actual work
* Called in 65816 native mode, 16 bit M & X
SHRVDU5LF     MX    %00                    ; Tell Merlin
              LDA   SHRYPIXEL
              SEC
              SBC   #16                    ; Height of this+next row
              CMP   SHRWINBTM
              BCC   :NEWPAGE               ; Less than 16 rows left
              LDA   SHRYPIXEL
              SEC
              SBC   #$08
              STA   SHRYPIXEL
              BRA   :DONE
:NEWPAGE      LDA   SHRWINTOP
              STA   SHRYPIXEL
:DONE         RTS
              MX    %11                    ; 8 bit again


* Handle carriage return in VDU5 mode
SHRVDU13      >>>   ENTMAIN
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDA   SHRWINLFT
              STA   SHRXPIXEL
:DONE         SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin
              >>>   XF2AUX,VDUXXRET


* Handle erasing char for VDU127 in VDU5 mode
* Called after SHRVDU08 has already backspaced cursor
SHRVDU127     >>>   ENTMAIN
              LDX   SHRYPIXEL              ; Screen row (Y-coord)
              LDA   SHRROWSL,X             ; Look up addr (LS byte)
              STA   A3L                    ; Stash in A3L
              LDA   SHRROWSH,X             ; Look up addr (MS byte)
              STA   A3H                    ; Stash in A3H
              LDA   #$E1                   ; Bank $E1
              STA   A4L
              LDX   SHRPIXELS
              CPX   #$02
              BNE   :MODE0
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDA   SHRXPIXEL              ; Screen col (X-coord)
              LSR   A                      ; Divide by 2
              BRA   :MODE1
:MODE0        CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDA   SHRXPIXEL              ; Screen col (X-coord)
              LSR   A                      ; Divide by 2
              LSR   A                      ; Divide by 4
              TAY
              LDX   #$00
              SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin
:L1           LDA   SHRGFXBGMASK
              STAL  [A3L],Y
              INY
              STAL  [A3L],Y
              DEY
              JSR   SHRNXTROWM             ; Advance A3L/H to next pixel row
              INX
              CPX   #$08                   ; Erased all 8 rows?
              BNE   :L1
              BRA   :DONE
:MODE1        MX    %00                    ; Tell Merlin it's 16 bit M&X
              TAY
              LDX   #$00
              SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin
:L2           LDA   SHRGFXBGMASK
              STAL  [A3L],Y
              INY
              STAL  [A3L],Y
              INY
              STAL  [A3L],Y
              INY
              STAL  [A3L],Y
              DEY
              DEY
              DEY
              JSR   SHRNXTROWM             ; Advance A3L/H to next pixel row
              INX
              CPX   #$08                   ; Erased all 8 rows?
              BNE   :L2
:DONE         SEC                          ; 65816 emulation mode
              XCE
              >>>   XF2AUX,VDUXXRET

* Advance A3L/H to next pixel row on screen
SHRNXTROWM    LDA   A3L                    ; Advance A3L/H to next row
              CLC
              ADC   #160
              STA   A3L
              LDA   A3H
              ADC   #$00
              STA   A3H
              RTS


* Plot actions: PLOT k,x,y
* k is in SHRVDUQ+4
* x is in SHRVDUQ+5,SHRVDUQ+6
* y is in SHRVDUQ+7,SHRVDUQ+8
*
* Plot actions:
*  $00+x - move/draw lines     Where x: 0 - Move relative
*  $40+x - plot point                   1 - Draw relative FG
* [$50+x - fill triangle]               2 - Draw relative Inv FG
* [$60+x - fill rectangle]              3 - Draw relative BG
* [$90+x - draw circle]                 4 - Move absolute
* [$98+x - fill circle]                 5 - Draw abs FG
*                                       6 - Draw abs Inv FG
*                                       7 - Draw abs BG
* Note: abs/rel handled in auxmem.vdu.s
* TODO: No triangle filling or other fancy ops yet
SHRPLOT       >>>   ENTMAIN
              >>>   SHRCOORD               ; Convert coordinates
              LDA   A1L                    ; Preserve converted x
              PHA
              LDA   A1H
              PHA
              LDA   A2L                    ; Preserve converted y
              PHA
              LDA   A2H
              PHA
              LDA   SHRVDUQ+4              ; k
              AND   #$03
              CMP   #$00                   ; Bits 0,1 clear -> just move
              BEQ   :S2
              JSR   SHRPLOTCOL             ; Handle colour selection
              LDA   SHRVDUQ+4              ; k
              AND   #$F0                   ; Keep MS nybble
              CMP   #$00                   ; Move or draw line
              BNE   :S1
              JSR   SHRLINE
              BRA   :S2
:S1           CMP   #$40                   ; Plot point
              BNE   :BAIL                  ; Other? Bail out

              CLC                          ; 65816 native mode
              XCE
              SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin
              JSR   SHRPOINT
              SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin

              BRA   :S2
:S2           PLA                          ; Store prev pt in screen coords
              STA   SHRYPIXEL+1
              PLA
              STA   SHRYPIXEL+0
              PLA
              STA   SHRXPIXEL+1
              PLA
              STA   SHRXPIXEL+0
:DONE         >>>   XF2AUX,GFXPLOTRET
:BAIL         PLA
              PLA
              PLA
              PLA
              LDA   SHRGFXFGMSK2           ; Restore original FG colour
              STA   SHRGFXFGMASK
              BRA   :DONE


* Handle colour selection for PLOT
SHRPLOTCOL    LDA   SHRGFXFGMASK           ; Preserve FG colour
              STA   SHRGFXFGMSK2
              LDA   SHRVDUQ+4              ; k
              AND   #$03
              CMP   #$02                   ; Inverse fFG
              BNE   :S1
              LDA   SHRGFXFGMASK           ; Load FG mask
              EOR   #$FF                   ; Negate / invert
              INC   A
              STA   SHRGFXFGMASK           ; Overwrite GF mask
              BRA   :DONE
:S1           CMP   #$03                   ; BG
              BNE   :DONE
              LDA   SHRGFXBGMASK           ; Load BG mask
              STA   SHRGFXFGMASK           ; Overwrite FG mask
:DONE         RTS


* Plot a point
* Called in 65816 native mode, 8 bit M & X
* On entry: A1L/H x-coordinate, A2L/H y-coordinate
SHRPOINT      REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDA   A2L                    ; y coordinate
              CMP   SHRWINBTM
              BMI   :OUT
              CMP   SHRWINTOP
              BEQ   :S1
              BPL   :OUT
:S1           LDA   A1L                    ; x coordinate
              CMP   SHRWINLFT
              BMI   :OUT
              CMP   SHRWINRGT
              BEQ   SHRPOINT2
              BPL   :OUT
              BRA   SHRPOINT2
:OUT          SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin
              RTS
SHRPOINT2     SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin

              LDX   A2L                    ; Screen row (Y-coord)
              LDA   SHRROWSL,X             ; Look up addr (LS byte)
              STA   A3L                    ; Stash in A3L
              LDA   SHRROWSH,X             ; Look up addr (MS byte)
              STA   A3H                    ; Stash in A3H
              LDA   #$E1                   ; Bank $E1
              STA   A4L

              LDX   A1L                    ; Store X-coord for later
              LSR   A1H                    ; Divide by 2
              ROR   A1L

              LDA   SHRPIXELS              ; Pixels per byte
              CMP   #$02                   ; 2 is 320-mode (MODE 1)
              BNE   :MODE0

              LDY   A1L                    ; Index into row of pixels
              TXA
              AND   #$01                   ; Keep LSB bit only
              TAX                          ; Index into :BITS320

              LDA   :BITS320,X             ; Get bit pattern for pixel to set
              BRA   SHRPLOTBYTE
              
:MODE0        LSR   A1H                    ; Divide X-coord by 2 again
              ROR   A1L
              LDY   A1L                    ; Index into row of pixels
              TXA
              AND   #$03                   ; Keep LSB two bits only
              TAX                          ; Index into :BITS640

              LDA   :BITS640,X             ; Get bit pattern for pixel to set

SHRPLOTBYTE   PHA
              LDA   SHRGFXACTION           ; GCOL action
              AND   #$0007                 ; Avoid table overflows
              ASL
              TAX
              PLA                          ; Recover bit pattern
              JMP   (:PLOTTBL, X)          ; Jump using jump table

:BITS320      DB    %11110000              ; Bit patterns for pixel ..
              DB    %00001111              ; .. within byte
:BITS640      DB    %11000000              ; Bit patterns for pixel ..
              DB    %00110000              ; .. within byte
              DB    %00001100
              DB    %00000011
:PLOTTBL      DW    SHRPLOTSET             ; Jump table for GCOL actions
              DW    SHRPLOTOR
              DW    SHRPLOTAND
              DW    SHRPLOTXOR
              DW    SHRPLOTNOT
              DW    SHRPLOTNOP
              DW    SHRPLOTCLR
              DW    SHRPLOTNOP


* Plot the specified colour (GCOL action 0)
* Pixel bit pattern in A
SHRPLOTSET    TAX                          ; Keep copy of bit pattern
              EOR   #$FF                   ; Invert bits
              AND   [A3L],Y                ; Load existing byte, clearing pixel
              STA   A1L
              TXA                          ; Get bit pattern back
              AND   SHRGFXFGMASK           ; Mask to set colour
              ORA   A1L                    ; OR into existing byte
              STA   [A3L],Y                ; Write to screen
              RTS


* OR with colour on screen (GCOL action 1)
* Pixel bit pattern in A
SHRPLOTOR     AND   SHRGFXFGMASK           ; Mask to set colour
              ORA   [A3L],Y                ; OR into existing byte
              STA   [A3L],Y                ; Write to screen
              RTS


* AND with colour on screen (GCOL action 2)
* Pixel bit pattern in A
SHRPLOTAND    TAX                          ; Keep copy of bit pattern
              AND   [A3L],Y                ; Mask bits to work on
              STA   A1L
              TXA                          ; Get bit pattern back
              AND   SHRGFXFGMASK           ; Mask to set colour
              AND   A1L                    ; AND with screen data
              STA   A1L
              TXA                          ; Get bit pattern back
              EOR   #$FF                   ; Invert
              AND   [A3L],Y                ; Mask remaining bits
              ORA   A1L                    ; Combine
              STA   [A3L],Y                ; Write to screen
              RTS


* XOR with colour on screen (GCOL action 3)
* Pixel bit pattern in A
SHRPLOTXOR    AND   SHRGFXFGMASK           ; Mask to set colour
              EOR   [A3L],Y                ; EOR into existing byte
              STA   [A3L],Y                ; Write to screen
              RTS


* NOT colour on screen (GCOL action 4)
* Pixel bit pattern in A
SHRPLOTNOT    TAX                          ; Keep copy of bit pattern
              STX   A1L
              LDA   [A3L],Y                ; Load existing byte
              EOR   #$FF                   ; Negate / invert existing byte
              AND   A1L                    ; Mask with bit pattern
              STA   A1L
              TXA                          ; Get bit pattern back
              EOR   #$FF                   ; Invert bits
              AND   [A3L],Y                ; Mask remaining bits
              ORA   A1L                    ; Combine
              STA   [A3L],Y                ; Write to screen
              RTS


* NO-OP (GCOL action 5)
* Pixel bit pattern in A
SHRPLOTNOP    RTS


* Clear (GCOL action 6)
* Pixel bit pattern in A, and also at top of stack
SHRPLOTCLR    EOR   #$FF                   ; Invert bits
              AND   [A3L],Y                ; Load existing byte, clearing pixel
              STA   [A3L],Y                ; Write to screen
              RTS


* Bresenham line drawing algorithm, entry point
* x0 is in SHRXPIXEL+0,SHRPIXEL+1
* y0 is in SHRYPIXEL
* x1 in A1L,A1H
* y1 in A2L
* Called in emulation mode.
* Uses TMPZP+0,+1
SHRLINE       LDA   A2L                    ; y1
              SEC
              SBC   SHRYPIXEL              ; Subtract y0
              BPL   :S1                    ; Skip if +ve
              EOR   #$FF                   ; Negate if -ve
              INC   A
:S1           STA   TMPZP+0                ; abs(y1 - y0)
              STZ   TMPZP+1                ; Pad to 16 bit
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDA   A1L                    ; Load x1 (A1L,A1H)
              SEC
              SBC   SHRXPIXEL              ; Subtract x0
              BPL   :S2                    ; Skip if +ve
              EOR   #$FFFF                 ; Negate if -ve
              INC   A
:S2           CMP   TMPZP                  ; Cmp abs(x1 - x0) w/ abs(y1 - y0)
              BCC   :YDOM                  ; abs(x1 - x0) < abs(y1 - y0)

:XDOM         LDA   SHRXPIXEL              ; x0
              CMP   A1L                    ; x1
              BPL   :X1                    ; x0 >= x1
              JMP   SHRLINELO              ; x0 < x1
:X1           JSR   SHRLINESWAP            ; Swap parms
              JMP   SHRLINELO

:YDOM         LDA   SHRYPIXEL              ; y0
              CMP   A2L                    ; y1
              BPL   :Y1                    ; y0 >= y1
              JMP   SHRLINEHI              ; y0 < y1
:Y1           JSR   SHRLINESWAP            ; Swap parms
              JMP   SHRLINEHI


* Swap (x0, y0) and (x1, y1)
* Called in 65816 native mode, 16 bit M &X
* Uses TMPZP+0,+1
SHRLINESWAP   LDA   SHRXPIXEL              ; x0
              STA   TMPZP
              LDA   A1L                    ; x1
              STA   SHRXPIXEL
              LDA   TMPZP
              STA   A1L
              LDA   SHRYPIXEL              ; y0
              STA   TMPZP
              LDA   A2L                    ; y1
              STA   SHRYPIXEL
              LDA   TMPZP
              STA   A2L
              RTS


* Plot x-dominant line (shallow gradient)
* Called in 65816 native mode, 16 bit M & X. Returns in emulation mode.
SHRLINELO     MX    %00                    ; Tell merlin 16 bit M & X
              LDA   A1L                    ; x1
              STA   :LIM                   ; We re-use A1L/H later
              SEC
              SBC   SHRXPIXEL              ; Subtract x0
              STA   :DX
              LDA   A2L                    ; y1
              SEC
              SBC   SHRYPIXEL              ; Subtract y0
              STA   :DY
              LDA   #$0001
              STA   :YI                    ; yi = 1

              LDA   :DY
              BPL   :S1                    ; Skip if dy = 0
              LDA   #$FFFF
              STA   :YI                    ; yi = -1
              EOR   :DY                    ; Negate dy
              INC   A
              STA   :DY                    ; dy = -dy

:S1           TAY                          ; dy
              ASL                          ; 2 * dy
              STA   :DY                    ; DY now (2 * dy)
              SEC
              SBC   :DX                    ; (2 * dy) - dx
              STA   :D                     ; D = (2 * dy) - dx
              LDA   SHRYPIXEL              ; y0
              STA   A2L                    ; y = y0 (re-using A2L/H)
              TYA
              SEC
              SBC   :DX
              ASL
              STA   :DX                    ; DX now (2 * (dy - dx)

              LDX   SHRXPIXEL              ; x = x0
:L1           STX   A1L                    ; Store x-coord for SHRPOINT
              PHX
              SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin
              JSR   SHRPOINT               ; x in A1L/H, y in A2L
              REP   #$31                   ; 16 bit M & X, CLC
              MX    %00                    ; Tell Merlin
              PLX
              LDA   :D
              BMI   :S2                    ; D < 0
              ADC   :DX
              STA   :D                     ; D = D + (2 * (dy - dx))
              LDA   A2L                    ; y
              CLC                          ; (Required)
              ADC   :YI
              STA   A2L                    ; y = y + yi
              BRA   :S3
:S2         ; CLC                          ; Already CC
              ADC   :DY
              STA   :D                     ; D = D + 2 * dy
:S3           INX
              CPX   :LIM                   ; Compare with x1
              BCC   :L1

              SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin
              RTS
* Zero page
:DX           EQU   TMPZP+0                ; dx initially, then (2 * (dy - dx))
:DY           EQU   TMPZP+2                ; dy initially, then (2 * dy)
:YI           EQU   TMPZP+4                ; +1 or -1
:D            EQU   TMPZP+6                ; D
:LIM          EQU   TMPZP+8                ; x1 gets stashed here


* Plot y-dominant line (steep gradient)
* Called in 65816 native mode, 16 bit M & X. Returns in emulation mode.
SHRLINEHI     MX    %00                    ; Tell Merlin 16 bit M & X
              LDA   A1L                    ; x1
              SEC
              SBC   SHRXPIXEL              ; Subtract x0
              STA   :DX
              LDA   A2L                    ; y1
              STA   :LIM                   ; We re-use A1L/H later
              SEC
              SBC   SHRYPIXEL              ; Subtract y0
              STA   :DY
              LDA   #$0001
              STA   :XI                    ; xi = 1

              LDA   :DX
              BPL   :S1                    ; Skip if dx = 0
              LDA   #$FFFF
              STA   :XI                    ; xi = -1
              EOR   :DX                    ; Negate dx
              INC   A
              STA   :DX                    ; dx = -dx

:S1           TAX                          ; dx
              ASL                          ; 2 * dx
              STA   :DX                    ; DX now (2 * dx)
              SEC
              SBC   :DY                    ; (2 * dx) - dy
              STA   :D                     ; D = (2 * dx) - dy
              LDA   SHRXPIXEL              ; x0
              STA   :X                     ; x = x0
              TXA
              SEC
              SBC   :DY
              ASL
              STA   :DY                    ; DY now (2 * (dx - dy)

              LDX   SHRYPIXEL              ; y = y0
:L1           LDA   :X
              STA   A1L                    ; Store x-coord for SHRPOINT
              STX   A2L                    ; Store y-coord for SHRPOINT
              PHX
              SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin
              JSR   SHRPOINT               ; x in A1L/H, y in A2L
              REP   #$31                   ; 16 bit M & X, CLC
              MX    %00                    ; Tell Merlin
              PLX
              LDA   :D
              BMI   :S2                    ; D < 0
              ADC   :DY
              STA   :D                     ; D = D + (2 * (dx - dy))
              LDA   :X                     ; x
              CLC                          ; (Required)
              ADC   :XI
              STA   :X                     ; x = x + xi
              BRA   :S3
:S2         ; CLC                          ; Already CC
              ADC   :DX
              STA   :D                     ; D = D + 2 * dx
:S3           INX
              CPX   :LIM                   ; Compare with y1
              BCC   :L1

              SEC                          ; 65816 emulation mode
              XCE
              MX    %11                    ; Tell Merlin
*              PLP                          ; Resume normal service
              RTS
* Zero page
:X            EQU   TMPZP+0
:DX           EQU   TMPZP+2                ; dx initially, then (2 * dx)
:DY           EQU   TMPZP+4                ; dy initially, then (2 * (dx - dy)))
:XI           EQU   TMPZP+6                ; +1 or -1
:D            EQU   TMPZP+8                ; D
:LIM          EQU   TMPZP+10               ; x1 gets stashed here


* Macro to convert high-resolution screen coordinates
* from 1280x1024 to 640x200 or 320x200
* On return: X-coordinate in A1L/H, Y-coordinate in A2L (A2H=0)
SHRCOORD      MAC
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin

* X-coordinate in SHRVDUQ+5,+6   1280/2=640 or 1280/4=320
              LDA   SHRVDUQ+5
              ASL                          ; Sign bit -> C
              ROR   SHRVDUQ+5              ; Signed divide /2

              LDA   SHRPIXELS              ; Pixels per byte
              AND   #$00FF                 ; Mask
              CMP   #$02                   ; 2 is 320-mode (MODE 1)
              BNE   SHRCOORDM0
              LDA   SHRVDUQ+5
              ASL                          ; Sign bit -> C
              ROR   SHRVDUQ+5              ; Signed divide /2
SHRCOORDM0    LDA   SHRVDUQ+5
              STA   A1L                    ; Result in A1L/H

* Y-coordinate in SHRVDUQ+7,+8   1024*25/128=200
              LDA   SHRVDUQ+7
              BMI   SHRCOORDNEG
              ASL                          ; *2
              ADC   SHRVDUQ+7              ; *3
              ASL                          ; *6
              ASL                          ; *12
              ASL                          ; *24
              ADC   SHRVDUQ+7              ; *25

* Clever speedup trick thanks to Kent Dickey @ A2Infinitum
* now we have valid data in acc[15:7], and we want to shift right 7 bits to
* get acc[8:0] as the valid bits.  If we left shift one bit and xba,
* we get acc[7:0] in the proper bits, so we just have to bring the bit we
* just shifted out back
* See: https://apple2infinitum.slack.com/archives/CA8AT5886/p1628877444215300
* for code on how to shift left 7 bits

              ASL                          ;
              AND   #$FF00                 ; Mask bits
              ADC   #0                     ; Add in carry (9th bit)
              XBA                          ; Clever trick: fewer shifts
              STA   A2L                    ; Into A2L/H
        
              SEC                          ; Back to emulation mode
              XCE
              MX    %11                    ; Tell Merlin
              BRA   SHRCOORDEND

SHRCOORDNEG   MX    %00                    ; Tell Merlin we are 16 bit
              EOR   #$FFFF                 ; Negate
              INC   A
              ASL                          ; *2
              ADC   SHRVDUQ+7              ; *3
              ASL                          ; *6
              ASL                          ; *12
              ASL                          ; *24
              ADC   SHRVDUQ+7              ; *25

* Clever speedup trick thanks to Kent Dickey @ A2Infinitum
* now we have valid data in acc[15:7], and we want to shift right 7 bits to
* get acc[8:0] as the valid bits.  If we left shift one bit and xba,
* we get acc[7:0] in the proper bits, so we just have to bring the bit we
* just shifted out back
* See: https://apple2infinitum.slack.com/archives/CA8AT5886/p1628877444215300
* for code on how to shift left 7 bits

              ASL                          ;
              AND   #$FF00                 ; Mask bits
              ADC   #0                     ; Add in carry (9th bit)
              XBA                          ; Clever trick: fewer shifts
              EOR   #$FFFF                 ; Negate
              INC   A
              STA   A2L                    ; Into A2L/H
        
              SEC                          ; Back to emulation mode
              XCE
              MX    %11                    ; Tell Merlin
*              PLP                          ; Normal service resumed
SHRCOORDEND   EOM


* Another coordinate transform, used by VDU25
* Same as SHRCOORD above, except it is entered in native, 16 bit M & X mode
* Assumes positive coordinates.
* On entry: X is offset into SHRVDUQ to find coordinate
* On return: Coverted coordinats in A1L/H, A2L/H
SHRCOORD2     MX    $00                    ; Tell Merlin it's 16 bit

* X-coordinate in SHRVDUQ+5,+6   1280/2=640
              LSR   SHRVDUQ,X              ; Unsigned divide /2
              LDA   SHRPIXELS              ; Pixels per byte
              AND   #$00FF                 ; Mask
              CMP   #$02                   ; 2 is 320-mode (MODE 1)
              BNE   SHRCOORD2M0
              LSR   SHRVDUQ,X              ; Unsigned divide /2 again
SHRCOORD2M0   LDA   SHRVDUQ,X
              STA   A1L                    ; Result in A1L/H

* Y-coordinate in SHRVDUQ+7,+8   1024*25/128=200
              LDA   SHRVDUQ+2,X
              ASL                          ; *2
              ADC   SHRVDUQ+2,X            ; *3
              ASL                          ; *6
              ASL                          ; *12
              ASL                          ; *24
              ADC   SHRVDUQ+2,X            ; *25

              ASL                          ;
              AND   #$FF00                 ; Mask bits
              ADC   #0                     ; Add in carry (9th bit)
              XBA                          ; Clever trick: fewer shifts
              STA   A2L                    ; Into A2L/H
              RTS


              MX    %11                    ; Following code is 8 bit again


* Clear the graphics window
SHRVDU16      >>>   ENTMAIN
              CLC                          ; 816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              INC   SHRWINTOP
              INC   SHRWINRGT
              LDX   SHRWINBTM

              LDA   SHRPIXELS
              AND   #$00FF
              CMP   #$02
              BNE   :M0                    ; MODE0

              LDA   SHRWINLFT
              LSR   A                      ; Divide left by 2
              INC   A                      ; Treat left column specially
              STA   :LEFTLIM
              LDA   SHRWINRGT
              LSR   A                      ; Divide right by 2
              STA   :RIGHTLIM
              BRA   :S0

:M0           LDA   SHRWINLFT
              LSR   A                      ; Divide left by 4
              LSR   A
              INC   A                      ; Treat left column specially
              STA   :LEFTLIM
              LDA   SHRWINRGT
              LSR   A                      ; Divide right by 4
              LSR   A
              STA   :RIGHTLIM
              BRA   :S0

:S0           SEP   #$30                   ; 8 bit M & X
              MX    %11                    ; Tell Merlin
:L1           LDY   :LEFTLIM
              LDA   SHRROWSL,X             ; Look up addr (LS byte)
              STA   A3L                    ; Stash in A3L
              LDA   SHRROWSH,X             ; Look up addr (MS byte)
              STA   A3H                    ; Stash in A3H
              LDA   #$E1                   ; Bank $E1
              STA   A4L

              LDA   SHRGFXBGMASK
:L2           CPY   :RIGHTLIM
              BCS   :S1
              STA   [A3L],Y
              INY
              CPY   :RIGHTLIM
              BRA   :L2

:S1           INX
              CPX   SHRWINTOP
              BNE   :L1

              LDA   SHRPIXELS
              CMP   #$02
              BNE   :MODE0

              LDA   SHRWINRGT
              AND   #$01
              TAX
              LDA   :RIGHT320,X            ; Bits to set
              JSR   SHRVDU16V              ; Handle right edge

              LDY   :LEFTLIM
              DEY                          ; Handle leftmost byte
              LDA   SHRWINLFT
              AND   #$01
              TAX
              LDA   :LEFT320,X             ; Bits to set
              JSR   SHRVDU16V              ; Handle left edge
              BRA   :DONE

:MODE0        LDA   SHRWINRGT
              AND   #$03
              TAX
              LDA   :RIGHT640,X            ; Bits to set
              JSR   SHRVDU16V              ; Handle right edge

              LDY   :LEFTLIM
              DEY                          ; Handle leftmost byte
              LDA   SHRWINLFT
              AND   #$03
              TAX
              LDA   :LEFT640,X             ; Bits to set
              JSR   SHRVDU16V              ; Handle left edge

:DONE         REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              DEC   SHRWINTOP
              DEC   SHRWINRGT

              SEC                          ; Back to 6502 emu mode
              XCE
              MX    %11                    ; Tell Merlin
              >>>   XF2AUX,SHRCLRRET
:LEFT320      DB    %11111111
              DB    %00001111
:LEFT640      DB    %11111111
              DB    %00111111
              DB    %00001111
              DB    %00000011
:RIGHT320     DB    %00000000
              DB    %11110000
:RIGHT640     DB    %00000000
              DB    %11000000
              DB    %11110000
              DB    %11111100
* Zero page
:LEFTLIM      EQU   TMPZP+0                ; 2 bytes of ZP
:RIGHTLIM     EQU   TMPZP+2                ; 2 bytes of ZP


* Helper routine to draw vertical lines
* Draw line from A1L,SHRWINBTM to A1L,SHRWINBTM in BG colour
* Called in 65816 native mode, 8 bit M & X
* On entry: Y - byte offset into row, A - bit pattern to set
SHRVDU16V     PHA
              LDX   SHRWINBTM
:L1           LDA   SHRROWSL,X             ; Look up addr (LS byte)
              STA   A3L                    ; Stash in A3L
              LDA   SHRROWSH,X             ; Look up addr (MS byte)
              STA   A3H                    ; Stash in A3H
              LDA   #$E1                   ; Bank $E1
              STA   A4L

              PLA
              PHA
              EOR   #$FF                   ; Invert bits
              AND   [A3L],Y                ; Load existing byte, clearing pixel
              STA   A1L
              PLA
              PHA
              AND   SHRGFXBGMASK           ; Mask to set colour
              ORA   A1L                    ; OR into existing byte
              STA   [A3L],Y                ; Write to screen

              INX
              CPX   SHRWINTOP
              BNE   :L1
              PLA
              RTS


* Validate graphics window parms & store if okay
* First 8 bytes of SHRVDUQ: left, bottom, right, top
SHRVDU24      >>>   ENTMAIN
              CLC                          ; 65816 native mode
              XCE
              REP   #$30                   ; 16 bit M & X
              MX    %00                    ; Tell Merlin
              LDA   SHRVDUQ+4              ; Right
              CMP   SHRVDUQ+0              ; Left
              BCC   :BAD                   ; right<left
              CMP   #1280                  ; width
              BCS   :BAD                   ; right>=width
              LDA   SHRVDUQ+6              ; Top
              CMP   SHRVDUQ+2              ; Bottom
              BCC   :BAD                   ; top<bottom
              CMP   #1024                  ; height
              BCS   :BAD                   ; top>=height
             
              LDX   #$00                   ; Start of SHRVDUQ 
              JSR   SHRCOORD2              ; Convert left, bottom
              LDA   A1L                    ; left converted
              STA   SHRWINLFT
              LDA   A2L                    ; bottom converted
              STA   SHRWINBTM
              LDX   #$04                   ; 4 byte offset
              JSR   SHRCOORD2              ; Convert right, top
              LDA   A1L                    ; right converted
              STA   SHRWINRGT
              LDA   A2L                    ; top converted
              STA   SHRWINTOP

              SEC                          ; 65816 emulation mode
              XCE
              >>>   XF2AUX,VDU24RET
:BAD          SEC                          ; 65816 emulation mode
              XCE
              >>>   XF2AUX,VDUXXRET


* Reset graphics window
* Initialize other locals (called on MODE)
SHRVDU26      >>>   ENTMAIN

              STZ   SHRWINLFT+0            ; Graphics window
              STZ   SHRWINLFT+1
              STZ   SHRWINBTM+0
              STZ   SHRWINBTM+1
              LDY   SHRPIXELS
              CPY   #$02
              BNE   :MODE0
              LDA   #<319
              STA   SHRWINRGT+0
              LDA   #>319
              STA   SHRWINRGT+1
              BRA   :S1
:MODE0        LDA   #<639
              STA   SHRWINRGT+0
              LDA   #>639
              STA   SHRWINRGT+1
:S1           LDA   #<199
              STA   SHRWINTOP+0
              LDA   #>199
              STA   SHRWINTOP+1

              STZ   SHRXPIXEL+0            ; Other locals
              STZ   SHRXPIXEL+1
              STZ   SHRYPIXEL+0
              STZ   SHRYPIXEL+1

              >>>   XF2AUX,VDU26RET


* Set up default palette
SHRDEFPALM    >>>   ENTMAIN
              LDY   #00                    ; Palette offset for 320 mode
              LDA   SHRPIXELS              ; Pixels per byte
              CMP   #$02                   ; 2 is 320-mode (MODE 1)
              BEQ   :S1
              LDY   #32                    ; Palette offset for 640 mode
:S1           LDX   #$00
:L1           LDA   PALETTE320,Y           ; Offset in Y computed above
              STAL  $E19E00,X              ; Palettes begin at $9E00 in $E1
              INX
              INY
              CPX   #32                    ; 32 bytes in palette
              BNE   :L1
              >>>   XF2AUX,SHRDEFPALRET


* Assign a 'physical' colour from the 16 colour palette to a
* 'logical' colour for the current mode
* On entry: A=logical colour, Y=physical colour
SHRPALCHANGE  >>>   ENTMAIN
              TAX
              TYA
              AND   #%00011110             ; Has already been shifted
              TAY
              LDA   SHRPIXELS              ; Pixels per byte
              CMP   #$02                   ; 2 is 320-mode (MODE 1)
              BEQ   :MODE320
              TXA
              AND   #%00000110             ; Has already been shifted
              TAX
              LDA   PALETTE320,Y           ; Byte 1 of physical colour
              STAL  $E19E00,X              ; Store in logical slot (4 copies)
              STAL  $E19E00+8,X
              STAL  $E19E00+16,X
              STAL  $E19E00+24,X
              LDA   PALETTE320+1,Y         ; Byte 2 of physical colour
              STAL  $E19E00+1,X            ; Store in logical slot (4 copies)
              STAL  $E19E00+9,X
              STAL  $E19E00+17,X
              STAL  $E19E00+25,X
              BRA   :DONE
:MODE320      TXA
              AND   #%00011110             ; Has already been shifted
              TAX
              LDA   PALETTE320,Y           ; Byte 1 of physical colour
              STAL  $E19E00,X              ; Store in logical slot
              LDA   PALETTE320+1,Y         ; Byte 2 of physical colour
              STAL  $E19E00+1,X            ; Store in logical slot
:DONE         >>>   XF2AUX,VDUXXRET 


* Assign a custom RGB colour to a 'logical' colour
* On entry: A=GB components, Y=R component, SHRVDUQ=logical colour
SHRPALCUSTOM  >>>   ENTMAIN
              LDX   SHRVDUQ
              PHA                          ; Preserve GB components
              LDA   SHRPIXELS              ; Pixels per byte
              CMP   #$02                   ; 2 is 320-mode (MODE 1)
              BEQ   :MODE320
              TXA
              AND   #%00000110             ; Has already been shifted
              TAX
              PLA                          ; Recover GB components
              STAL  $E19E00,X              ; Store in logical slot (4 copies)
              STAL  $E19E00+8,X
              STAL  $E19E00+16,X
              STAL  $E19E00+24,X
              TYA                          ; R component
              STAL  $E19E00+1,X            ; Store in logical slot (4 copies)
              STAL  $E19E00+9,X
              STAL  $E19E00+17,X
              STAL  $E19E00+25,X
              BRA   :DONE
:MODE320      TXA
              AND   #%00011110             ; Has already been shifted
              TAX
              PLA                          ; Recover GB components
              STAL  $E19E00,X              ; Store in logical slot
              TYA                          ; R component
              STAL  $E19E00+1,X            ; Store in logical slot
:DONE         >>>   XF2AUX,VDUXXRET 
              

* Table of addresses of SHR rows (in reverse order)
SHRROWSL      DB    <$9c60
              DB    <$9bc0
              DB    <$9b20
              DB    <$9a80
              DB    <$99e0
              DB    <$9940
              DB    <$98a0
              DB    <$9800
              DB    <$9760
              DB    <$96c0
              DB    <$9620
              DB    <$9580
              DB    <$94e0
              DB    <$9440
              DB    <$93a0
              DB    <$9300
              DB    <$9260
              DB    <$91c0
              DB    <$9120
              DB    <$9080
              DB    <$8fe0
              DB    <$8f40
              DB    <$8ea0
              DB    <$8e00
              DB    <$8d60
              DB    <$8cc0
              DB    <$8c20
              DB    <$8b80
              DB    <$8ae0
              DB    <$8a40
              DB    <$89a0
              DB    <$8900
              DB    <$8860
              DB    <$87c0
              DB    <$8720
              DB    <$8680
              DB    <$85e0
              DB    <$8540
              DB    <$84a0
              DB    <$8400
              DB    <$8360
              DB    <$82c0
              DB    <$8220
              DB    <$8180
              DB    <$80e0
              DB    <$8040
              DB    <$7fa0
              DB    <$7f00
              DB    <$7e60
              DB    <$7dc0
              DB    <$7d20
              DB    <$7c80
              DB    <$7be0
              DB    <$7b40
              DB    <$7aa0
              DB    <$7a00
              DB    <$7960
              DB    <$78c0
              DB    <$7820
              DB    <$7780
              DB    <$76e0
              DB    <$7640
              DB    <$75a0
              DB    <$7500
              DB    <$7460
              DB    <$73c0
              DB    <$7320
              DB    <$7280
              DB    <$71e0
              DB    <$7140
              DB    <$70a0
              DB    <$7000
              DB    <$6f60
              DB    <$6ec0
              DB    <$6e20
              DB    <$6d80
              DB    <$6ce0
              DB    <$6c40
              DB    <$6ba0
              DB    <$6b00
              DB    <$6a60
              DB    <$69c0
              DB    <$6920
              DB    <$6880
              DB    <$67e0
              DB    <$6740
              DB    <$66a0
              DB    <$6600
              DB    <$6560
              DB    <$64c0
              DB    <$6420
              DB    <$6380
              DB    <$62e0
              DB    <$6240
              DB    <$61a0
              DB    <$6100
              DB    <$6060
              DB    <$5fc0
              DB    <$5f20
              DB    <$5e80
              DB    <$5de0
              DB    <$5d40
              DB    <$5ca0
              DB    <$5c00
              DB    <$5b60
              DB    <$5ac0
              DB    <$5a20
              DB    <$5980
              DB    <$58e0
              DB    <$5840
              DB    <$57a0
              DB    <$5700
              DB    <$5660
              DB    <$55c0
              DB    <$5520
              DB    <$5480
              DB    <$53e0
              DB    <$5340
              DB    <$52a0
              DB    <$5200
              DB    <$5160
              DB    <$50c0
              DB    <$5020
              DB    <$4f80
              DB    <$4ee0
              DB    <$4e40
              DB    <$4da0
              DB    <$4d00
              DB    <$4c60
              DB    <$4bc0
              DB    <$4b20
              DB    <$4a80
              DB    <$49e0
              DB    <$4940
              DB    <$48a0
              DB    <$4800
              DB    <$4760
              DB    <$46c0
              DB    <$4620
              DB    <$4580
              DB    <$44e0
              DB    <$4440
              DB    <$43a0
              DB    <$4300
              DB    <$4260
              DB    <$41c0
              DB    <$4120
              DB    <$4080
              DB    <$3fe0
              DB    <$3f40
              DB    <$3ea0
              DB    <$3e00
              DB    <$3d60
              DB    <$3cc0
              DB    <$3c20
              DB    <$3b80
              DB    <$3ae0
              DB    <$3a40
              DB    <$39a0
              DB    <$3900
              DB    <$3860
              DB    <$37c0
              DB    <$3720
              DB    <$3680
              DB    <$35e0
              DB    <$3540
              DB    <$34a0
              DB    <$3400
              DB    <$3360
              DB    <$32c0
              DB    <$3220
              DB    <$3180
              DB    <$30e0
              DB    <$3040
              DB    <$2fa0
              DB    <$2f00
              DB    <$2e60
              DB    <$2dc0
              DB    <$2d20
              DB    <$2c80
              DB    <$2be0
              DB    <$2b40
              DB    <$2aa0
              DB    <$2a00
              DB    <$2960
              DB    <$28c0
              DB    <$2820
              DB    <$2780
              DB    <$26e0
              DB    <$2640
              DB    <$25a0
              DB    <$2500
              DB    <$2460
              DB    <$23c0
              DB    <$2320
              DB    <$2280
              DB    <$21e0
              DB    <$2140
              DB    <$20a0
              DB    <$2000

SHRROWSH      DB    >$9c60
              DB    >$9bc0
              DB    >$9b20
              DB    >$9a80
              DB    >$99e0
              DB    >$9940
              DB    >$98a0
              DB    >$9800
              DB    >$9760
              DB    >$96c0
              DB    >$9620
              DB    >$9580
              DB    >$94e0
              DB    >$9440
              DB    >$93a0
              DB    >$9300
              DB    >$9260
              DB    >$91c0
              DB    >$9120
              DB    >$9080
              DB    >$8fe0
              DB    >$8f40
              DB    >$8ea0
              DB    >$8e00
              DB    >$8d60
              DB    >$8cc0
              DB    >$8c20
              DB    >$8b80
              DB    >$8ae0
              DB    >$8a40
              DB    >$89a0
              DB    >$8900
              DB    >$8860
              DB    >$87c0
              DB    >$8720
              DB    >$8680
              DB    >$85e0
              DB    >$8540
              DB    >$84a0
              DB    >$8400
              DB    >$8360
              DB    >$82c0
              DB    >$8220
              DB    >$8180
              DB    >$80e0
              DB    >$8040
              DB    >$7fa0
              DB    >$7f00
              DB    >$7e60
              DB    >$7dc0
              DB    >$7d20
              DB    >$7c80
              DB    >$7be0
              DB    >$7b40
              DB    >$7aa0
              DB    >$7a00
              DB    >$7960
              DB    >$78c0
              DB    >$7820
              DB    >$7780
              DB    >$76e0
              DB    >$7640
              DB    >$75a0
              DB    >$7500
              DB    >$7460
              DB    >$73c0
              DB    >$7320
              DB    >$7280
              DB    >$71e0
              DB    >$7140
              DB    >$70a0
              DB    >$7000
              DB    >$6f60
              DB    >$6ec0
              DB    >$6e20
              DB    >$6d80
              DB    >$6ce0
              DB    >$6c40
              DB    >$6ba0
              DB    >$6b00
              DB    >$6a60
              DB    >$69c0
              DB    >$6920
              DB    >$6880
              DB    >$67e0
              DB    >$6740
              DB    >$66a0
              DB    >$6600
              DB    >$6560
              DB    >$64c0
              DB    >$6420
              DB    >$6380
              DB    >$62e0
              DB    >$6240
              DB    >$61a0
              DB    >$6100
              DB    >$6060
              DB    >$5fc0
              DB    >$5f20
              DB    >$5e80
              DB    >$5de0
              DB    >$5d40
              DB    >$5ca0
              DB    >$5c00
              DB    >$5b60
              DB    >$5ac0
              DB    >$5a20
              DB    >$5980
              DB    >$58e0
              DB    >$5840
              DB    >$57a0
              DB    >$5700
              DB    >$5660
              DB    >$55c0
              DB    >$5520
              DB    >$5480
              DB    >$53e0
              DB    >$5340
              DB    >$52a0
              DB    >$5200
              DB    >$5160
              DB    >$50c0
              DB    >$5020
              DB    >$4f80
              DB    >$4ee0
              DB    >$4e40
              DB    >$4da0
              DB    >$4d00
              DB    >$4c60
              DB    >$4bc0
              DB    >$4b20
              DB    >$4a80
              DB    >$49e0
              DB    >$4940
              DB    >$48a0
              DB    >$4800
              DB    >$4760
              DB    >$46c0
              DB    >$4620
              DB    >$4580
              DB    >$44e0
              DB    >$4440
              DB    >$43a0
              DB    >$4300
              DB    >$4260
              DB    >$41c0
              DB    >$4120
              DB    >$4080
              DB    >$3fe0
              DB    >$3f40
              DB    >$3ea0
              DB    >$3e00
              DB    >$3d60
              DB    >$3cc0
              DB    >$3c20
              DB    >$3b80
              DB    >$3ae0
              DB    >$3a40
              DB    >$39a0
              DB    >$3900
              DB    >$3860
              DB    >$37c0
              DB    >$3720
              DB    >$3680
              DB    >$35e0
              DB    >$3540
              DB    >$34a0
              DB    >$3400
              DB    >$3360
              DB    >$32c0
              DB    >$3220
              DB    >$3180
              DB    >$30e0
              DB    >$3040
              DB    >$2fa0
              DB    >$2f00
              DB    >$2e60
              DB    >$2dc0
              DB    >$2d20
              DB    >$2c80
              DB    >$2be0
              DB    >$2b40
              DB    >$2aa0
              DB    >$2a00
              DB    >$2960
              DB    >$28c0
              DB    >$2820
              DB    >$2780
              DB    >$26e0
              DB    >$2640
              DB    >$25a0
              DB    >$2500
              DB    >$2460
              DB    >$23c0
              DB    >$2320
              DB    >$2280
              DB    >$21e0
              DB    >$2140
              DB    >$20a0
              DB    >$2000