;;; -*- Mode: asm; indent-tabs-mode: t; tab-width: 8 -*-

.proc circle
        .include "circle.inc"

        ;; Because loop is so big, We need to save position in pointer
        LDA #<while_x_bigger_then_y
        STA jmp_location_pointer
        LDA #>while_x_bigger_then_y
        STA jmp_location_pointer + 1

        ;; X_rel = radius (share the same address)
        ;;Y_rel =0
        LDA #$00
        STA Y_rel

        ;; t1 = radius >> 4
        LDA radius
        LSR
        LSR
        LSR
        LSR
        STA t1


draw_center_px_in_circle:
        JSR  pixel_draw
        LDA btp_mem_pos
        STA btp_mem_pos_center
        LDA btp_mem_pos + 1
        STA btp_mem_pos_center + 1

        ;; btp_mem_pos_center_two = 2*btp_mem_pos_center | used later for calculating btp_mem_pos_inv
        Mult_16 btp_mem_pos_center, btp_mem_pos_center + 1
        Sub_16 btp_mem_pos_center, btp_mem_pos_center +1, #$08, #$00
        Sub_16 btp_mem_pos_center, btp_mem_pos_center +1, #$40, #$01

draw_lower_px_in_circle:
        CLC
        LDA Y_pos
        STA temp_
        ADC radius
        STA Y_pos

        JSR pixel_draw

        LDA btp_mem_pos
        STA btp_mem_pos_qcb
        STA btp_mem_pos_qdb
        LDA btp_mem_pos + 1
        STA btp_mem_pos_qdb + 1
        STA btp_mem_pos_qcb + 1

        Sub_16 btp_mem_pos_qdb, btp_mem_pos_qdb +1, #$08, #$00

        LDA temp_
        STA Y_pos
draw_right_px_in_circle:
        CLC
        LDA X_pos
        ADC radius
        STA X_pos
        ;; We only draw the first pixel using absolute position.
        ;; After that we use relative position.
        JSR pixel_draw
        ;; This sets byte_to_paint, btp_mem_pos and Y

        LDA btp_mem_pos
        STA btp_mem_pos_qda
        LDA btp_mem_pos + 1
        STA btp_mem_pos_qda + 1
        Sub_16 btp_mem_pos_qda, btp_mem_pos_qda +1, #$40, #$01

while_x_bigger_then_y:
        SEC
        ;;Draw pixels and does the ypos incrementation logic
        ;; WARNING expects C=1 before and C =0 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

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


        ;;We have named the parts of the circle as such.
        ;;               |
        ;;      qbb (7)  |      qab (8)
        ;;               |
        ;;   qba (2)     |         qaa (1)
        ;;---------------X-----------------> X
        ;;   qca (4)     |         qda (3)
        ;;               |
        ;;      qcb (5)  |      qdb (6)
        ;;               |
        ;;               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.
;; Note that I have the draw_qxx in listed pairs. Each pair chair the same Y-register :)
STY Y_copy
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_qba: ;;mirror_technique
        LDX byte_to_paint
	LDA inverse_factor_value, X;; (see END.s)
	TAX
        ORA (btp_mem_pos_qba), Y
        STA (btp_mem_pos_qba), Y
draw_qda:; y is inverted

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

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

draw_qca: ;;mirror technique

        TXA
        ORA (btp_mem_pos_qca), Y
        STA (btp_mem_pos_qca), Y

draw_qcb:; xy swoped
        LDA log, X
        TAY

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

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

draw_qdb:; xy swaped and y is inverted.

        LDA inverse_factor_value, X
        STA temp__

        ;;Uses modifyed Y from above
        ORA (btp_mem_pos_qdb), Y
        STA (btp_mem_pos_qdb), Y
draw_qbb:

        STY temp_
        LDA #$07
        SBC temp_
        TAY

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

draw_qab:; xy swoped + mirroring

        LDA temp__
        ORA (btp_mem_pos_qab), Y
        STA (btp_mem_pos_qab), Y


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

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:


        ;;t1 += y
        ; C==0 from circle_help
        LDA t1
        ADC Y_rel
        STA t1
        ;; t2 = t1 - x
        SEC
        SBC X_rel
        STA t2
        ;; if t2 < 0 then skip to endif
        ;; we can skipp CMP #$00 because SBC above do the same
        BMI endif
if:
decrement_x_pos:
        DEC X_rel
        ASL byte_to_paint
        BCC decrement_x_pos_end
move_8px_left:
        ;; Next chunk is 8 addresses away. Look in pixel_draw for more detail.
        ;; -8.
        ;; C = 1 because branching
        Sub_16 btp_mem_pos, btp_mem_pos + 1, #$08, #$00, ! ;+8

        ;; Y is inverted
        Sub_16 btp_mem_pos_qda, btp_mem_pos_qda + 1, #$08, #$00, ! ;+8
        ;; X and Y has swoped
        Sub_16 btp_mem_pos_qcb, btp_mem_pos_qcb + 1, #$40, #$01, ! ;-320
        ;; X and Y has swoped and Y has inverted
        Sub_16 btp_mem_pos_qdb, btp_mem_pos_qdb +1, #$40, #$01, ! ;+320

        ;; Restores byte to paint
        INC byte_to_paint

        LDA t2
decrement_x_pos_end:
        STA t1    ; t1 = t2
endif:
        ;; repeat if X > Y
        LDA X_rel
        CMP Y_rel

        BCC end
        JMP (jmp_location_pointer)
end:
        RTS
.endproc