c64-livecoding/wip-hugo/routines/circle/circle_help.s

.proc circle_help ; This is because jmp cant jump that long!
.include "circle.inc"

        ;; WARNING expects C=1 before and C =0 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!


        ;;We have named the parts of the circle as such.
        ;;               |
        ;;      qbb      |      qab
        ;;               |
        ;;   qba         |         qaa
        ;;---------------X-----------------> X
        ;;   qca         |         qda
        ;;               |
        ;;      qcb      |      qdb
        ;;               |
        ;;               v Y
        ;; The q stands for quarter, whe have 4 quarter, and each quarter is split into 2

        ;; We first calculate all btp_mem_pos for the inverted half quarters!
calculate:
        ;; qab = 2*center - qcb
        ;; qca = 2*center - qaa
        ;; qba = 2*center - qda
        ;; qbb = 2*center - qdb
        ;; a = 2*center - b comes from that a = center -(b-center)

        LDA btp_mem_pos_center_two
        SBC btp_mem_pos_qcb
        STA btp_mem_pos_qab
        LDA btp_mem_pos_center_two + 1
        SBC btp_mem_pos_qcb + 1
        STA btp_mem_pos_qab + 1

        LDA btp_mem_pos_center_two
        SBC btp_mem_pos
        STA btp_mem_pos_qca
        LDA btp_mem_pos_center_two + 1
        SBC btp_mem_pos + 1
        STA btp_mem_pos_qca + 1

        LDA btp_mem_pos_center_two
        SBC btp_mem_pos_qda
        STA btp_mem_pos_qba
        LDA btp_mem_pos_center_two + 1
        SBC btp_mem_pos_qda + 1
        STA btp_mem_pos_qba + 1

        LDA btp_mem_pos_center_two
        SBC btp_mem_pos_qdb
        STA btp_mem_pos_qbb
        LDA btp_mem_pos_center_two + 1
        SBC btp_mem_pos_qdb + 1
        STA btp_mem_pos_qbb + 1
end_calculation:

;; Lets draw all half-quatrons of the circle. This draws only 8 pixels per iteration.

draw_qaa:
        LDA byte_to_paint ;A byte containing a single 1. Coresponds to X position in the chunk.
        ORA (btp_mem_pos), Y
        STA (btp_mem_pos), Y

draw_qcb:; xy swoped
        STY temp
        LDA byte_to_paint
        STA temp__

        ;;modify Y_pos
        LDY #$00
        JMP goto_loop
loop:
        INY
goto_loop:
        ASL byte_to_paint
        BCC loop
revert_byte_to_paint:
        LDA temp__
        STA byte_to_paint

        ;;modify X_pos
        LDX temp
       	LDA binary_factor, X; (see END.s)


        ORA (btp_mem_pos_qcb), Y
        STA (btp_mem_pos_qcb), Y

draw_qdb:; xy swaped and y is inverted.
        ;;modify X
        LDA #$07
        SBC temp
        TAX
        LDA binary_factor, X; (see END.s)
        TAX

        ;;Uses modifyed Y from above
        ORA (btp_mem_pos_qdb), Y
        STA (btp_mem_pos_qdb), Y
draw_qbb:;; the one not working
        STY temp_
        LDA #$07
        SBC temp_
        TAY

	LDA inverse_factor_value, X;; (see END.s)

        ORA (btp_mem_pos_qbb), Y
        STA (btp_mem_pos_qbb), Y

        ;LDY temp_

draw_qab:; xy swoped + mirroring

        ;STY temp_
        ;LDA #$07
        ;SBC temp_
        ;TAY

        TXA
        ORA (btp_mem_pos_qab), Y
        STA (btp_mem_pos_qab), Y

draw_qda:; y is inverted

        ;; invert Y, this is shared with qca
        LDA #$07
        SBC temp
        TAY

        LDA byte_to_paint
        ORA (btp_mem_pos_qda), Y
        STA (btp_mem_pos_qda), Y

draw_qca: ;;mirror technique

        ;; calculate byte_to_paint_inv 00000001 --> 10000000, 00000010 --> 01000000 ... etc
        ;; uses a table!
        LDX byte_to_paint
	LDA inverse_factor_value, X;; (see END.s)
	TAX ;; A is saved to x because qba use this as well

	; A = byte_to_paint_inv
        ORA (btp_mem_pos_qca), Y
        STA (btp_mem_pos_qca), Y

        ;;Recover the Y value (we changed it because evrything is inverted)
        LDY temp

draw_qba: ;;mirror_technique
        TXA
        ORA (btp_mem_pos_qba), Y
        STA (btp_mem_pos_qba), Y


increment_y_pos:
        INC Y_rel ; y++
        DEY
        BPL increment_y_pos_end
move_8px_down:
        LDY #$07
        ;; Switch to chunk bellow
        ; So we subtract  #$0140
        ; C = 1 because branching!
        Sub_16 btp_mem_pos, btp_mem_pos + 1, #$40, #$01, ! ;-320
        ;; Y is inverted
        Add_16 btp_mem_pos_qda, btp_mem_pos_qda + 1, #$3f, #$01,! ;+320
        ;; X and Y has swopped
        Sub_16 btp_mem_pos_qcb, btp_mem_pos_qcb + 1, #$07, #$00,! ;-8
        ;; X and Y has swoped and Y has inverted
        Add_16 btp_mem_pos_qdb, btp_mem_pos_qdb +1, #$07, #$00,! ;+8
increment_y_pos_end:
        RTS
.endproc