4cade/src/fx/fx.dhgr.precomputed.1bit.a

;license:MIT
;(c) 2019-2022 by 4am
;

         !source "src/fx/fx.hgr.precomputed.1bit.a"

!macro BUILD_SPARSE_BITMASKS_1BIT_DHGR .copymasks, .mirror_copymasks {
         ; build sparse lookup tables for bitmasks
         ldx   #$00
         txa
-        sta   .copymasks, x
         sta   $C005
         sta   .copymasks, x
         sta   $C004
         inx
         bne   -

         lda   #%00000111
         sta   .copymasks+$80
         sta   .mirror_copymasks+$40

         lda   #%00011000
         sta   .copymasks+$A0
         sta   .mirror_copymasks+$20

         lda   #%01100000
         sta   .copymasks+$C0
         sta   .mirror_copymasks

         sta   $C005

         lda   #%10000011
         sta   .copymasks
         sta   .mirror_copymasks+$C0

         lda   #%10001100
         sta   .copymasks+$20
         sta   .mirror_copymasks+$A0

         lda   #%10110000
         sta   .copymasks+$40
         sta   .mirror_copymasks+$80

         lda   #%11000000
         sta   .copymasks+$60
         sta   .mirror_copymasks+$60

         sta   $C004
; X=0
}

!macro FX_PRECOMPUTED_1BIT_DHGR .coords {
         +BUILD_SPARSE_BITMASKS_1BIT_DHGR copymasks, mirror_copymasks
         +BUILD_HGR_LOOKUP_TABLES_X_IS_ALREADY_0 hgrlo, hgr1hi
         +BUILD_HGR_MIRROR_LOOKUP_TABLES hgrlomirror, hgr1himirror
         +BUILD_MIRROR_COLS_DHGR mirror_cols
         +COPY_TO_0 start, end
         jmp   InputLoop
start
!pseudopc 0 {
Exit1Bit rts
InputLoop
         ldy   #0
input=*+1
         ldx   .coords               ; first value: HGR row (only 0..95 will be in input array)
         bmi   Exit1Bit              ; if > 127 then we're done
         +ROW_X_TO_BASE_ADDRESSES
         +ROW_X_TO_MIRROR_ADDRESSES

         inc   input
         lda   (input), y
         +HIGH_3_LOW_5 input
         sty   <y
         clc
bankloop
         lda   copymasks, x
         beq   +
         sta   <copymask

         ; main 1x2 block in top-left quadrant
src1=*+1
         lda   $FDFD, y
         eor   (<dest1), y
copymask=*+1
         and   #$FD                  ; SMC
         eor   (<dest1), y
dest1=*+1
         sta   $FDFD, y
src2=*+1
         lda   $FDFD, y
         eor   (<dest2), y
         and   <copymask
         eor   (<dest2), y
dest2=*+1
         sta   $FDFD, y

         ; corresponding 1x2 block in bottom-left quadrant (opposite row, original column)
         +COPY_BIT_ZP mirror_src1, mirror_dest1, copymask
         +COPY_BIT_ZP mirror_src2, mirror_dest2, copymask

+
         lda   mirror_copymasks, x              ; exists at the same address in mainmem and auxmem but each is different
         beq   +
         sta   <mirror_copymask
         ; corresponding 1x2 block in bottom-right quadrant (opposite row, opposite column)
         lda   mirror_cols, y                   ; duplicated in mainmem and auxmem
         tay
mirror_src1=*+1
         lda   $FDFD, y
         eor   (<mirror_dest1), y
mirror_copymask=*+1
         and   #$FD                             ; SMC
         eor   (<mirror_dest1), y
mirror_dest1=*+1
         sta   $FDFD, y
mirror_src2=*+1
         lda   $FDFD, y
         eor   (<mirror_dest2), y
         and   <mirror_copymask
         eor   (<mirror_dest2), y
mirror_dest2=*+1
         sta   $FDFD, y

         ; corresponding 1x2 block in top-right quadrant (same row, opposite column)
         +COPY_BIT_ZP src1, dest1, mirror_copymask
         +COPY_BIT_ZP src2, dest2, mirror_copymask
+
         bcs   +
         sta   $C003
         sta   $C005
y=*+1
         ldy   #$FD
         sec
         bcs   bankloop
+        sta   $C002
         sta   $C004

         +INC_INPUT_AND_LOOP InputLoop
}
end
}

!macro FX_PRECOMPUTED_1BIT_DHGR_DITHER .coords, .endcoords {
         +BUILD_DITHER_MASKS_DHGR dithermasks
         +BUILD_SPARSE_BITMASKS_1BIT_DHGR copymasks, mirror_copymasks
         +BUILD_HGR_LOOKUP_TABLES_X_IS_ALREADY_0 hgrlo, hgr1hi
         +BUILD_HGR_MIRROR_LOOKUP_TABLES hgrlomirror, hgr1himirror
         +BUILD_MIRROR_COLS_DHGR mirror_cols

         ; phase 1 - in reverse, with additional masking
         +COPY_TO_0 start, end

         ; set up starting coordinate for reading coordinates in reverse order
         +LDADDR .endcoords-2
         sta   <input
         sty   <input+1

         ; set up EOF marker to stop reading coordinates in reverse order
         lda   #$80
         sta   .coords-2

         ; set up logic to advance to next coordinates in reverse order
         ldx   #(next2_end-next2_start-1)
-        lda   next2_start, x
         sta   <next, x
         dex
         bpl   -

         jsr   InputLoop

         bit   KBD
         bmi   start

         ; phase 2 - in order, without additional masking
         +COPY_TO_0 start, end

         ; redirect additional masking pointers to an array that contains #$FFs (so no masking)
         lda   #<no_masks
         sta   <evenrow_ptr
         sta   <oddrow_ptr

         jmp   InputLoop
start
!pseudopc 0 {
Exit1Bit rts
evenrow_ptr
         !word evenrow_masks
oddrow_ptr
         !word oddrow_masks
InputLoop
         ldy   #0
input=*+1
         ldx   .coords               ; first value: HGR row (only 0..95 will be in input array)
         bmi   Exit1Bit              ; if > 127 then we're done
         +ROW_X_TO_BASE_ADDRESSES
         +ROW_X_TO_MIRROR_ADDRESSES

         iny
         lda   (input), y
         +HIGH_3_LOW_5 input
         sty   <y
         clc
bankloop
         lda   copymasks, x
         beq   +
         sta   <copymask

         ; main 1x2 block in top-left quadrant
src1=*+1
         lda   $FDFD, y
         eor   (<dest1), y
copymask=*+1
         and   #$FD                  ; SMC
         and   (<evenrow_ptr), y
         eor   (<dest1), y
dest1=*+1
         sta   $FDFD, y
src2=*+1
         lda   $FDFD, y
         eor   (<dest2), y
         and   <copymask
         and   (<oddrow_ptr), y
         eor   (<dest2), y
dest2=*+1
         sta   $FDFD, y

         ; corresponding 1x2 block in bottom-left quadrant (opposite row, original column)
         +COPY_BIT_ZP_DITHER mirror_src1, mirror_dest1, copymask, oddrow_ptr
         +COPY_BIT_ZP_DITHER mirror_src2, mirror_dest2, copymask, evenrow_ptr

+
         lda   mirror_copymasks, x
         beq   +
         sta   <mirror_copymask
         ; corresponding 1x2 block in bottom-right quadrant (opposite row, opposite column)
         lda   mirror_cols, y
         tay
mirror_src1=*+1
         lda   $FDFD, y
         eor   (<mirror_dest1), y
mirror_copymask=*+1
         and   #$FD                             ; SMC
         and   (<oddrow_ptr), y
         eor   (<mirror_dest1), y
mirror_dest1=*+1
         sta   $FDFD, y
mirror_src2=*+1
         lda   $FDFD, y
         eor   (<mirror_dest2), y
         and   <mirror_copymask
         and   (<evenrow_ptr), y
         eor   (<mirror_dest2), y
mirror_dest2=*+1
         sta   $FDFD, y

         ; corresponding 1x2 block in top-right quadrant (same row, opposite column)
         +COPY_BIT_ZP_DITHER src1, dest1, mirror_copymask, evenrow_ptr
         +COPY_BIT_ZP_DITHER src2, dest2, mirror_copymask, oddrow_ptr
+
         bcs   +
         sta   $C003
         sta   $C005
y=*+1
         ldy   #$FD
         sec
         jmp   bankloop
+        sta   $C002
         sta   $C004

next
         inc   <input
         inc   <input
         bne   +
         bit   KBD
         bmi   ++
         inc   <input+1
+        jmp   InputLoop
++       rts
}
end

next2_start
!pseudopc next {
         lda   <input
         php
         dec   <input
         dec   <input
         plp
         bne   +
         dec   <input+1
         bit   KBD
         bmi   ++
+        jmp   InputLoop
++       rts
}
next2_end
}