;	
;	Simple Implementation of
;	The Mandelbrot Set
;	
;	By Samuel Pearce
;	


;	
;	Constants
;	
	SCALE	= 16			; Screen scale (1px = ~0.09)
MAX_ITERS	= 12			; Maximum number of iterations to do
	OFFS_X	= $E7			; -25, X-Offset of the render view
	OFFS_Y	= $F1			; -15, Y-Offset of the render view
	THRESH	= 2				; If a point goes beyond this value (2.0 fixpt) it's not in the set

;	
;	Variables
;	
	ARG_1	= $00			; 16-bit maths argument
	ARG_2	= $02			; 16-bit maths argument
	ARG_3	= $04			; 16-bit maths argument
	WORKNR	= $06			; 32-bit product

	PT_IDX	= $20			; 16-bit pointer into point array
	CN_C_R	= $22			; Complex Number 'C' Real Part
	CN_C_I	= $24			; Complex Number 'C' Imaginary Part
	CN_Z_R	= $26			; Complex Number 'Z' Real Part
	CN_Z_I	= $28			; Complex Number 'Z' Imaginary Part
	GRID_X	= $2A			; Current X coordinate in framebuffer
	GRID_Y	= $2B			; Current Y coordinate in framebuffer
	ITERS	= $2C			; Number of iterations performed
	FB_IDX	= $2D			; Index into framebuffer of currently edited byte
	FBMASK	= $2E			; Mask of the framebuffer bit to alter
	LOAD_N	= $2F			; Current loading char number

	POINTS	= $7000			; Storage of 32x32 4-Byte Complex Numbers


	.WORD	$8000
	.ORG	$8000

;---------------------------;
;	Program Start & Setup	;
;---------------------------;

	reset:	CLD				; Clear decimal mode
			CLI				; Clear interrupts

			LDA #<POINTS	; Set point array index
			STA PT_IDX+0	; to the start of its buffer
			LDA #>POINTS
			STA PT_IDX+1

init_pts:	LDA #<str_setup	; Get 'setup' string pointer
			JSR putstring	; Write 'setup' string
			JSR ldch_init	; Start loader animation
			LDA #$00		; Clear A
			TAX 			; Clear X
			STA ITERS		; Init num of iterations
clear_pts:	LDA #$00		; Clear A
			STA (PT_IDX,X)	; Clear point byte
			INC	PT_IDX+0	; Increment points index low byte
			BNE @nohi		; Skip if lower byte hasn't rolled over
			INC	PT_IDX+1	; Increment points index high byte
			JSR ldch_inc	; Update loader animation
	@nohi:	LDA PT_IDX+1	; Check points index high byte
			BPL clear_pts	; Loop until high bit of high byte is set ($8000)
			JSR ldch_bksp	; Finish loader animation

			LDA #$FF			; Load A with all bits set
			JSR GL_BLIT_FILL	; Fill all pixels of the framebuffer
			LDA #$0A		; Load newline
			STA $FF00		; Write newline to console

;---------------------------;
;	Main Iteration Loop		;
;---------------------------;

iterate:	LDA #$00
			STA GRID_X		; Set current coordinate to 0/0
			STA GRID_Y
			STA FB_IDX		; Set index into framebuffer to the start

			LDA #<POINTS	; Set point array index
			STA PT_IDX+0	; to the start of its buffer
			LDA #>POINTS
			STA PT_IDX+1

			LDA #%10000000	; Init framebuffer bitmask
			STA FBMASK		; Write to mask
			LDA #<str_calc	; Get 'calculating' string pointer
			JSR putstring	; Write 'calculating' string to console
			JSR ldch_init	; Set up loading animation

calc_point:	LDY FB_IDX		; Get current framebuffer index
			LDA GL_FRAME_BUF,Y	; Get current byte
			AND FBMASK		; Mask out only current bit
			BNE	@cont		; If current bit is not yet set, continue to calculation
			JMP loop_end	; Else skip all calculation

	@cont:	LDY #3			; Set Y to index of bytes to copy
	get_z:	LDA (PT_IDX),Y	; Get Yth byte of Z
			STA CN_Z_R,Y	; Write to zero page variable
			DEY				; Decrement counter
			BPL get_z		; Loop past 0

			; Calculate constant C using screen coords
			CLC				; Clear Carry
			LDA GRID_X		; Get X coordinate
			ADC #OFFS_X		; Add offset
			JSR shift_4r	; Shift the A register 4 times right (rolling into lower byte in X)
			STA CN_C_R+1	; Store value into complex number C's real component
			STX CN_C_R+0

			CLC				; Clear Carry
			LDA GRID_Y		; Get Y coordinate
			ADC #OFFS_Y		; Add offset
			JSR shift_4r	; Shift the A register 4 times right (rolling into lower byte in X)
			STA CN_C_I+1	; Store value into complex number C's imaginary component
			STX CN_C_I+0

			LDA ITERS		; Check iteration count to see if it's the first one
			BEQ add_const	; If so, skip squaring (initial value is just 0)

			; Iterate value (Z = Z^2 + C)
			; Because Z is complex, squaring looks like:
			;
			;     Z(r) = Z(r)^2 - Z(i)^2
			;     Z(i) = 2 * Z(r) * Z(i)
			;
square_z:	LDX #CN_Z_R		; $F0 = Z(r)^2
			LDY #CN_Z_R		; Load argument pointers
			JSR cpy_args	; Copy to maths args
			JSR M_MUL		; Multiply
			LDX #$F0		; Load result pointer
			JSR cpy_result	; Copy to temp var

			LDX #CN_Z_I		; $F2 = Z(i)^2
			LDY #CN_Z_I		; Load argument pointers
			JSR cpy_args	; Copy to maths args
			JSR M_MUL		; Multiply
			LDX #$F2		; Load result pointer
			JSR cpy_result	; Copy to temp var

			LDX #CN_Z_R		; Z(i) = Z(r) * Z(i)
			LDY #CN_Z_I		; Load argument pointers
			JSR cpy_args	; Copy to maths args
			JSR M_MUL		; Multiply
			LDX #CN_Z_I		; Load result pointer
			JSR cpy_result	; Copy to temp var

			ASL CN_Z_I+0	; Z(i) <<= 1; Z(i) = Z(i) * 2
			ROL CN_Z_I+1	; 16-bit shift left

			SEC				; Z(r) = $F0 - $F2
			LDA	$F0+0		; Get low byte arg 1
			SBC	$F2+0		; Subtract low byte arg 2
			STA	CN_Z_R+0	; Store result
			LDA	$F0+1		; Get high byte arg 1
			SBC	$F2+1		; Subtract high byte arg 2
			STA	CN_Z_R+1	; Store result

add_const:	CLC				; Z(r) = Z(r) + C(r)
			LDA	CN_Z_R+0	; Get low byte arg 1
			ADC	CN_C_R+0	; Add low byte arg 2
			STA	CN_Z_R+0	; Store result
			LDA	CN_Z_R+1	; Get high byte arg 1
			ADC	CN_C_R+1	; Add high byte arg 2
			STA	CN_Z_R+1	; Store result

			CLC				; Z(i) = Z(i) + C(i)
			LDA	CN_Z_I+0	; Get low byte arg 1
			ADC	CN_C_I+0	; Add low byte arg 2
			STA	CN_Z_I+0	; Store result
			LDA	CN_Z_I+1	; Get high byte arg 1
			ADC	CN_C_I+1	; Add high byte arg 2
			STA	CN_Z_I+1	; Store result

			; Check if iterated value is outside of bounds
			; Boundary = (-2.0/-2.0) to (2.0/2.0)
check_pt:	LDA CN_Z_R+1	; Get high byte of real component
			BMI @cp_rn		; Jump to negative check if byte is negative
	@cp_rp:	CMP #$02		; Check if it's above 2
			BCC @cp_i		; Z(r) <  2.0; Continue to imaginary check
			BNE clear_px	; Z(r) >= 3.0; Clear pixel
			LDA CN_Z_R+0	; Get low byte
			BNE clear_px	; Z(r) >  2.0; Clear pixel
			JMP @cp_i
	@cp_rn: CMP #$FE		; Check if it's above -2.0
			BCC clear_px	; Z(r) < -2.0; Clear pixel

	@cp_i:	LDA CN_Z_I+1	; Get high byte of imaginary component
			BMI @cp_in		; Jump to negative check if byte is negative
	@cp_ip:	CMP #$02		; Check if it's above 2
			BCC @cpend		; Z(r) <  2.0; Continue to imaginary check
			BNE clear_px	; Z(r) >= 3.0; Clear pixel
			LDA CN_Z_I+0	; Get low byte
			BNE clear_px	; Z(r) >  2.0; Clear pixel
			JMP @cpend
	@cp_in: CMP #$FE		; Check if it's above -2.0
			BCC clear_px	; Z(r) < -2.0; Clear pixel

	@cpend:	JMP loop_end	; Point is still in the set

clear_px:	LDA FBMASK		; Get the framebuffer mask
			EOR #$FF		; Invert mask
			LDY FB_IDX		; Load framebuf index
			AND GL_FRAME_BUF,Y	; Load byte from framebuf and mask out current bit
			STA GL_FRAME_BUF,Y	; Store updated byte to framebuf

loop_end:	; Write new Z value to point array
			; and increment point array index 4 times (at start of next value)
			LDX #0			; Clear X
			LDY #0			; Clear Y
	put_z:	LDA CN_Z_R,X	; Get Xth byte of Z on zero page
			STA (PT_IDX),Y	; Write to the point array
			INC PT_IDX+0	; Increment point index low byte
			BNE @e			; skip increment if we didn't wrap
			INC PT_IDX+1	; Increment high byte
		@e:	INX				; Increment counter
			CPX #4			; Check if we've copied all bytes yet
			BCC put_z		; Loop through all point bytes

			LSR FBMASK		; Shift the bitmask
			BCC @nobe		; Bit is still in the mask; Skip Increment
			ROR FBMASK		; Roll carry back into bitmask
			INC FB_IDX		; Increment framebuffer index

	@nobe:	INC GRID_X		; Increment X coordinate
			LDA GRID_X		; Check X value
			CMP #$20		; Loop until 32
			BCC @again

			LDA #0			; Clear A
			STA GRID_X		; Reset X to 0 for next row
			JSR ldch_inc	; Update loading animation

			INC GRID_Y		; Increment Y coordinate
			LDA GRID_Y		; Check Y value
			CMP #$20		; Loop until 32
			BCS @fdone		; if carry is set, we're done with this frame
	@again:	JMP calc_point	; Jump back up to calculate next point

	@fdone:	JSR GL_DRAW_BUF	; Draw framebuf to screen

			INC ITERS		; Increment number of iterations
			LDA ITERS		; Fetch iteration count
			CMP #MAX_ITERS	; Check if we've reached the limit
			BCS fin			; Yes: Skip to end
			JMP iterate		; No: Loop again

	fin:	LDA #<str_done	; Get 'done' string pointer
			JSR putstring	; Write 'done' string to console

	end:	JMP end			; Infinite loop to halt

;-------------------------------;
;	Libraries & Subroutines		;
;-------------------------------;


;	Shift A right 4 bits rolling into X
;	Returns the 16-bit result with A as the high byte and X as the low byte
shift_4r:	TAX				; Preserve A
			AND #$80		; Mask sign bit
			STA $F1			; Store sign for later
			LDA #$00		; Clear A
			STA $F0			; Clear 2nd temp var
			TXA				; Retrieve A
			LDY #4			; Set up loop counter
	@shift:	LSR A			; Shift high byte
			ORA $F1			; Set new bit to same as sign
			ROR $F0			; Shift low byte (get carry from high byte)
			DEY				; Decrement counter
			BNE @shift		; Loop Y times
			LDX $F0
			RTS


;	Copies two 16-bit args from a zero page addr to $00/$02
;	Arg 1: X, Arg 2: Y
cpy_args:	LDA $00,X		; Copy arg 1 lo byte
			STA ARG_1+0
			LDA $01,X		; Copy arg 1 hi byte
			STA ARG_1+1
			LDX $00,Y		; Copy arg 2 lo byte
			STX ARG_2+0
			LDX $01,Y		; Copy arg 2 hi byte
			STX ARG_2+1
			RTS


;	Copies multiplication result from 32-bit temp range to zero page
;	Dest: X
cpy_result:	LDA WORKNR+1	; Get new lo byte
			STA $00,X		; Store to provided pointer
			LDA WORKNR+2	; Get new hi byte
			STA $01,X		; Store
			RTS


;	Loading Char subroutines

ldch_init:	LDY #0			; Setup loading char number
			STY LOAD_N		; Store number to zpage variable
			JMP ldch_print	; Print first char
ldch_inc:	JSR ldch_bksp	; Clear previous char
			INC LOAD_N		; Increment loader number
			LDA LOAD_N		; Get loader number
			AND #%0011		; Mask to keep value in 0-3
			STA LOAD_N		; Save new value
			TAY				; Transfer to Y reg
ldch_print:	LDA ldch_chars,Y; Get current load char
			STA $FF00		; Write loading char to console
			RTS
ldch_bksp:	LDA #$08		; Load backspace
			STA $FF00		; write to console, removing previous loader char
			RTS
ldch_chars:	.BYTE "-\|/"	; List of loading characters


;	Simple putstring
;	Takes low byte of string address in A

putstring:	STA $F0			; Store low byte of address
			LDA #>str_setup	; Get high byte of string page
			STA $F1			; Store high byte
			LDY #0			; Clear Y
	@char:	LDA ($F0),Y		; Get char from string
			BEQ	@done		; Check if we've reached the end
			STA $FF00		; Write it to the console
			INY				; Increment index
			JMP @char		; Loop until null terminator
	@done:	RTS

str_setup:	.ASCIIZ "Setting up... "
str_calc:	.ASCIIZ "Calculating... "
str_done:	.ASCIIZ "Done!"


;	
;	Include my simple 16-bit Maths library
;	that provides rational values and multiplication
;	
.INCLUDE "maths.asm"

;	
;	Include my basic Graphics Library
;	that provides a 32x32 1bpp screen
;	
.INCLUDE "jraphics.asm"