diff --git a/Makefile b/Makefile index c94074b..711adcd 100644 --- a/Makefile +++ b/Makefile @@ -2,11 +2,8 @@ all : mandel.xex -mandel.xex : mandel.o mandel-core.o tables.o atari-xex.cfg - ld65 -C ./atari-xex.cfg --mapfile mandel.map -o $@ mandel.o mandel-core.o tables.o atari.lib - -mandel.s : mandel.c mandel.h - cc65 -o $@ mandel.c +mandel.xex : mandel.o tables.o atari-asm-xex.cfg + ld65 -C ./atari-asm-xex.cfg --mapfile mandel.map -o $@ mandel.o tables.o %.o : %.s ca65 -o $@ $< @@ -16,7 +13,8 @@ tables.s : tables.js clean : rm -f tables.s - rm -f mandel.s rm -f *.o rm -f *.xex rm -f mandel.map + + diff --git a/atari-xex.cfg b/atari-xex.cfg deleted file mode 100644 index 467d9d4..0000000 --- a/atari-xex.cfg +++ /dev/null @@ -1,69 +0,0 @@ -# Sample linker configuration for C programs using the Atari binary file support. -# Use with: cl65 -tatari -Catari-xex.cfg prog.c -o prog.xex -FEATURES { - STARTADDRESS: default = $8000; -} -SYMBOLS { - __SYSTEM_CHECK__: type = import; # force inclusion of "system check" load chunk - __STACKSIZE__: type = weak, value = $0800; # 2k stack - __STARTADDRESS__: type = export, value = %S; - __RESERVED_MEMORY__: type = weak, value = $0000; - __SYSCHKHDR__: type = export, value = 0; # Disable system check header - __SYSCHKTRL__: type = export, value = 0; # Disable system check trailer - __TABLESEG_START__: type = weak, value = $2E00 + $0300; - __TABLESEG_SIZE__: type = weak, value = 6 * $100; - __BANKSY_START__: type = weak, value = $4000; - __BANKSY_SIZE__: type = weak, value = $4000; - __FRAMEBUFFER_START__: type = weak, value = $A000; -} -MEMORY { -# Note -- $80 and $81 (LOMEM) appear to be reserved in ZP. - ZP: file = "", define = yes, start = $0082, size = $007E; -# "system check" load chunk - SYSCHKCHNK: file = %O, start = $2E00, size = $0300; -# Note $a000-$bfff is against the BASIC cartridge, may require booting with OPTION. - TABLES: file = %O, define = yes, start = __TABLESEG_START__, size = __TABLESEG_SIZE__; -# We reserve $4000-7fff for the bank-switch window. -# In theory we could keep data and code here that we only use on 48k/64k systems. - BANKSWITCH: file = "", define = yes, start = __BANKSY_START__, size = __BANKSY_SIZE__; -# "main program" load chunk - MAIN: file = %O, define = yes, start = %S, size = __FRAMEBUFFER_START__ - __STACKSIZE__ - __RESERVED_MEMORY__ - %S; -} -FILES { - %O: format = atari; -} -FORMATS { - atari: runad = start, - initad = SYSCHKCHNK: __SYSTEM_CHECK__; -} -SEGMENTS { - ZEROPAGE: load = ZP, type = zp; - EXTZP: load = ZP, type = zp, optional = yes; - SYSCHK: load = SYSCHKCHNK, type = rw, define = yes, optional = yes; - TABLES: load = TABLES, type = ro, optional = yes, align = 256; - BANKSWICH: load = BANKSWITCH, type = ro, optional = yes; - STARTUP: load = MAIN, type = ro, define = yes; - LOWBSS: load = MAIN, type = rw, optional = yes; # not zero initialized - LOWCODE: load = MAIN, type = ro, define = yes, optional = yes; - ONCE: load = MAIN, type = ro, optional = yes; - CODE: load = MAIN, type = ro, define = yes; - RODATA: load = MAIN, type = ro; - DATA: load = MAIN, type = rw; - INIT: load = MAIN, type = rw, optional = yes; - BSS: load = MAIN, type = bss, define = yes; -} -FEATURES { - CONDES: type = constructor, - label = __CONSTRUCTOR_TABLE__, - count = __CONSTRUCTOR_COUNT__, - segment = ONCE; - CONDES: type = destructor, - label = __DESTRUCTOR_TABLE__, - count = __DESTRUCTOR_COUNT__, - segment = RODATA; - CONDES: type = interruptor, - label = __INTERRUPTOR_TABLE__, - count = __INTERRUPTOR_COUNT__, - segment = RODATA, - import = __CALLIRQ__; -} diff --git a/bitmul.s b/bitmul.s deleted file mode 100644 index df84704..0000000 --- a/bitmul.s +++ /dev/null @@ -1,124 +0,0 @@ -; the old 16-bit bit-and-shift multiplier -; copied from old code, won't compile as-is - -; inner loop for imul16 -; bitnum < 8: 25 or 41 cycles -; bitnum >= 8: 30 or 46 cycles -.macro bitmul16 arg1, arg2, result, bitnum - .local zero - .local one - .local next - - ; does 16-bit adds - ; arg1 and arg2 are treated as unsigned - ; negative signed inputs must be flipped first - - ; 7 cycles up to the branch - - ; check if arg1 has 0 or 1 bit in this place - ; 5 cycles either way - .if bitnum < 8 - lda arg1 ; 3 cyc - and #(1 << (bitnum)) ; 2 cyc - .else - lda arg1 + 1 ; 3 cyc - and #(1 << ((bitnum) - 8)) ; 2 cyc - .endif - bne one ; 2 cyc - -zero: ; 18 cyc, 23 cyc - lsr result + 3 ; 5 cyc - jmp next ; 3 cyc - -one: ; 32 cyc, 37 cyc - ; 16-bit add on the top bits - clc ; 2 cyc - lda result + 2 ; 3 cyc - adc arg2 ; 3 cyc - sta result + 2 ; 3 cyc - lda result + 3 ; 3 cyc - adc arg2 + 1 ; 3 cyc - ror a ; 2 cyc - get a jump on the shift - sta result + 3 ; 3 cyc -next: - ror result + 2 ; 5 cyc - ror result + 1 ; 5 cyc - .if bitnum >= 8 - ; we can save 5 cycles * 8 bits = 40 cycles total by skipping this byte - ; when it's all uninitialized data - ror result ; 5 cyc - .endif - -.endmacro - -; 5 to 25 cycles -.macro check_sign arg - ; Check sign bit and flip argument to postive, - ; keeping a count of sign bits in the X register. - .local positive - lda arg + 1 ; 3 cyc - bpl positive ; 2 cyc - neg16 arg ; 18 cyc - inx ; 2 cyc -positive: -.endmacro - -; 518 - 828 cyc -.macro imul16 dest, arg1, arg2 - copy16 FR0, arg1 ; 12 cyc - copy16 FR1, arg2 ; 12 cyc - jsr imul16_func ; 470-780 cyc - copy32 dest, FR2 ; 24 cyc -.endmacro - - -.macro shift_round_16 arg, shift - .repeat shift - shl32 arg - .endrepeat - round16 arg -.endmacro - -.macro imul16_round dest, arg1, arg2, shift - copy16 FR0, arg1 ; 12 cyc - copy16 FR1, arg2 ; 12 cyc - jsr imul16_func ; 470-780 cyc - shift_round_16 FR2, shift - copy16 dest, FR2 + 2 ; 12 cyc -.endmacro - -; min 470 cycles -; max 780 cycles -.proc imul16_func - arg1 = FR0 ; 16-bit arg (clobbered) - arg2 = FR1 ; 16-bit arg (clobbered) - result = FR2 ; 32-bit result - - ldx #0 ; 2 cyc - ; counts the number of sign bits in X - check_sign arg1 ; 5 to 25 cyc - check_sign arg2 ; 5 to 25 cyc - - ; zero out the 32-bit temp's top 16 bits - lda #0 ; 2 cyc - sta result + 2 ; 3 cyc - sta result + 3 ; 3 cyc - ; the bottom two bytes will get cleared by the shifts - - ; unrolled loop for maximum speed, at the cost - ; of a larger routine - ; 440 to 696 cycles - .repeat 16, bitnum - ; bitnum < 8: 25 or 41 cycles - ; bitnum >= 8: 30 or 46 cycles - bitmul16 arg1, arg2, result, bitnum - .endrepeat - - ; In case of mixed input signs, return a negative result. - cpx #1 ; 2 cyc - bne positive_result ; 2 cyc - neg32 result ; 34 cyc -positive_result: - - rts ; 6 cyc -.endproc diff --git a/mandel.c b/mandel.c deleted file mode 100644 index f287fa3..0000000 --- a/mandel.c +++ /dev/null @@ -1,15 +0,0 @@ -/** - * The UI and I/O wrapper for the Mandelbrot runner, in C. - * - * For the moment *all* logic is in mandel-core.s, I'm just - * trying to get this to run within a cc65 environment. - * Eventually just the inner loop fun will live in there. - */ - -#include -#include -#include "mandel.h" - -void main(void) { - mandel_start(); -} \ No newline at end of file diff --git a/mandel.h b/mandel.h deleted file mode 100644 index e43fad7..0000000 --- a/mandel.h +++ /dev/null @@ -1,4 +0,0 @@ -#include - -// From mandel-core.s: -extern void mandel_start(void); diff --git a/mandel-core.s b/mandel.s similarity index 83% rename from mandel-core.s rename to mandel.s index a43894d..ec9f17f 100644 --- a/mandel-core.s +++ b/mandel.s @@ -1,45 +1,44 @@ -.zeropage +; Our zero-page vars +ox = $80 ; fixed6.26: center point x +oy = $84 ; fixed6.26: center point y +cx = $88 ; fixed6.26: c_x +cy = $8c ; fixed6.26: c_y -ox: .res 4 ; fixed6.26: center point x -oy: .res 4 ; fixed6.26: center point y -cx: .res 4 ; fixed6.26: c_x -cy: .res 4 ; fixed6.26: c_y +zx = $90 ; fixed6.26: z_x +zy = $94 ; fixed6.26: z_y +zx_2 = $98 ; fixed6.26: z_x^2 +zy_2 = $9c ; fixed6.26: z_y^2 -zx: .res 4 ; fixed6.26: z_x -zy: .res 4 ; fixed6.26: z_y -zx_2: .res 4 ; fixed6.26: z_x^2 -zy_2: .res 4 ; fixed6.26: z_y^2 +zx_zy = $a0 ; fixed6.26: z_x * z_y +dist = $a4 ; fixed6.26: z_x^2 + z_y^2 +sx = $a8 ; i16: screen pixel x +sy = $aa ; i16: screen pixel y +z_buffer_active = $ac ; boolean: 1 if we triggered the lake, 0 if not +z_buffer_start = $ad ; u8: index into z_buffer +z_buffer_end = $ae ; u8: index into z_buffer +iter = $af ; u8: iteration count -zx_zy: .res 4 ; fixed6.26: z_x * z_y -dist: .res 4 ; fixed6.26: z_x^2 + z_y^2 +ptr = $b0 ; u16 +pixel_ptr = $b2 ; u16 +zoom = $b4 ; u8: zoom shift level +fill_level = $b5 ; u8 +pixel_color = $b6 ; u8 +pixel_mask = $b7 ; u8 +pixel_shift = $b8 ; u8 +pixel_offset = $b9 ; u8 +palette_offset = $ba ; u8 +chroma_offset = $bb ; u8 +palette_ticks = $bc ; u8 +chroma_ticks = $bd ; u8 +count_frames = $be ; u8 +; free space $bf -z_buffer_active: .res 1 ; boolean: 1 if we triggered the lake, 0 if not -z_buffer_start: .res 1 ; u8: index into z_buffer -z_buffer_end: .res 1 ; u8: index into z_buffer -iter: .res 1 ; u8: iteration count -ptr: .res 2 ; u16 -pixel_ptr: .res 2 ; u16 -temp: .res 2 ; u16 -temp2: .res 2 ; u16 - -.data -; can move to .data -sx: .res 2 ; i16: screen pixel x -sy: .res 2 ; i16: screen pixel y -zoom: .res 1 ; u8: zoom shift level -fill_level: .res 1 ; u8 -pixel_color: .res 1 ; u8 -pixel_mask: .res 1 ; u8 -pixel_shift: .res 1 ; u8 -pixel_offset: .res 1 ; u8 -palette_offset: .res 1 ; u8 -chroma_offset: .res 1 ; u8 -palette_ticks: .res 1 ; u8 -chroma_ticks: .res 1 ; u8 -count_frames: .res 1 ; u8 -count_iters: .res 2 ; u16 -text_col: .res 1 ; u8 -text_row: .res 1 ; u8 +count_iters = $c0 ; u16 +text_col = $c2 ; u8 +text_row = $c3 ; u8 +; free space c4-cb +temp = $cc ; u16 +temp2 = $ce ; u16 palette_delay = 23 chroma_delay = 137 @@ -132,8 +131,6 @@ KEY_E = 42 KEY_X = 22 KEY_Y = 43 -.data - .struct float48 exponent .byte mantissa .byte 5 @@ -145,6 +142,7 @@ KEY_Y = 43 .import sqr_lobyte .import sqr_hibyte +.data strings: str_self: @@ -363,7 +361,7 @@ z_buffer: .word 0 .endrepeat -.export _mandel_start +.export start ;max_fill_level = 6 max_fill_level = 3 @@ -436,13 +434,11 @@ input_max: add 4, dest, arg1, arg2 .endmacro -; 2-7 cycles +; 8 cycles .macro add_carry dest - .scope - bcc after ; 2 cyc - inc dest ; 5 cyc - after: - .endscope + lda dest ; 3 cyc + adc #0 ; 2 cyc + sta dest ; 3 cyc .endmacro ; 2 + 9 * byte cycles @@ -533,20 +529,6 @@ input_max: neg 4, arg .endmacro -.macro copy_neg bytes, dest, arg - sec ; 2 cyc - .repeat bytes, byte ; 8 * byte cycles - lda #00 ; 2 cyc - sbc arg + byte ; 3 cyc - sta dest + byte ; 3 cyc - .endrepeat -.endmacro - -; 18 cycles -.macro copy_neg16 dest, arg - copy_neg 2, dest, arg -.endmacro - ; 11-27 + 18 * shift cycles ; 65-81 cycles for shift=3 .macro shift_round_16 arg, shift @@ -558,6 +540,8 @@ input_max: ; input: arg1, arg2 as fixed4.12 ; output: dest as fixed8.24 +; patch point jsr at 16 bytes in +imul16_patch_offset = 16 .macro imul16 dest, arg1, arg2 copy16 FR0, arg1 ; 12 cyc copy16 FR1, arg2 ; 12 cyc @@ -567,22 +551,23 @@ input_max: ; input: arg as fixed4.12 ; output: dest as fixed8.24 -;.macro sqr16 dest, arg -; copy16 FR0, arg ; 12 cyc -; jsr sqr16_func ; ? cyc -; copy32 dest, FR2 ; 24 cyc -;.endmacro +; patch point jsr at 8 bytes in +sqr16_patch_offset = 8 +.macro sqr16 dest, arg + copy16 FR0, arg ; 12 cyc + jsr sqr16_func ; ? cyc + copy32 dest, FR2 ; 24 cyc +.endmacro ; input: arg as u8 ; output: dest as u16 ; clobbers a, x -; 19 cyc .macro sqr8 dest, arg - ldx arg ; 3 cyc - lda sqr_lobyte,x ; 5 cyc - sta dest ; 3 cyc - lda sqr_hibyte,x ; 5 cyc - sta dest + 1 ; 3 cyc + ldx arg + lda sqr_lobyte,x + sta dest + lda sqr_hibyte,x + sta dest + 1 .endmacro .segment "TABLES" @@ -603,57 +588,32 @@ bank_switch_table: .macro imul8 dest, arg1, arg2, xe .if xe ; using 64KB lookup table - ; 50-55 cycles - ; min: 11 + 9 + 9 + 21 = 50 - ; max: 11 + 9 + 9 + 26 = 55 + ; 50-70 cycles ; clobbers x, y, dest, ptr .scope output = dest ; top 2 bits are the table bank selector - ; note we keep arg2 in X after this lookup as we need it later! ldx arg2 ; 3 cyc lda bank_switch_table,x ; 4 cyc sta PORTB ; 4 cyc ; bottom 14 bits except the LSB are the per-bank table index ; add $4000 for the bank pointer - ; note the low byte of ptr is assumed to remain at 0! do not clobber it! - txa ; 2 cyc and #$3f ; 2 cyc ora #$40 ; 2 cyc sta ptr + 1 ; 3 cyc - ; mask off the low bit for the index, as the table contains - ; entries for every other arg1 value... - lda arg1 ; 3 cyc - tay ; 2 cyc - and #1 ; 2 cyc - bne odd ; 2 cyc - - even: ; copy the entry into output - lda (ptr),y ; 5 cyc - sta output ; 3 cyc - iny ; 2 cyc - lda (ptr),y ; 5 cyc - sta output + 1 ; 3 cyc - jmp done ; 3 cyc - - odd: - - ; skip the LSB for the index - dey ; 2 cyc - - ; add arg2 one last time for the skipped bit - txa ; 2 cyc - clc ; 2 cyc - adc (ptr), y ; 5 cyc - sta output ; 3 cyc - lda #0 ; 2 cyc - iny ; 2 cyc - adc (ptr),y ; 5 cyc - sta output + 1 ; 3 cyc + lda arg1 ; 3 cyc + tax ; 2 cyc + and #$fe ; 2 cyc + tay ; 2 cyc + lda (ptr),y ; 5 cyc + sta output ; 3 cyc + iny ; 2 cyc + lda (ptr),y ; 5 cyc + sta output+1 ; 3 cyc ; note: we are not restoring memory to save 6 cycles! ; this means those 16kb have to be switched back to base RAM @@ -662,6 +622,20 @@ bank_switch_table: ;;lda #$81 ; 2 cyc - disabled ;;sta PORTB ; 4 cyc - disabled + ; check that 1 bit we skipped to fit into space + txa ; 2 cyc + and #1 ; 2 cyc + beq done ; 2 cyc + + ; add arg2 one last time for the skipped bit + clc ; 2 cyc + lda arg1 ; 3 cyc + adc output ; 3 cyc + sta output ; 3 cyc + lda #0 ; 2 cyc + adc output+1 ; 3 cyc + sta output+1 ; 3 cyc + done: .endscope .else @@ -795,128 +769,95 @@ inner_loop: .endproc -; min base mem: 81 * 4 + 22 * 2 + 10 = 378 cyc -; max base mem: 92 * 4 + 27 * 2 + 50 = 472 cyc -; min ext-mem: 50 * 4 + 22 * 2 + 10 = 254 cyc -; max ext-mem: 55 * 4 + 27 * 2 + 50 = 324 cyc -.macro imul16_impl result, arg1, arg2, xe - .scope - ;arg1 ; 16-bit arg - ;arg2 ; 16-bit arg - ;result ; 32-bit result (output) - inter = temp2 ; 16-bit temporary (clobbered) +.macro imul16_impl xe + .local arg1 + .local arg2 + .local result + .local inter + .local arg1_pos + .local arg2_pos + arg1 = FR0 ; 16-bit arg (clobbered) + arg2 = FR1 ; 16-bit arg (clobbered) + result = FR2 ; 32-bit result + inter = temp2 - ; h1l1 * h2l2 - ; (h1*256 + l1) * (h2*256 + l2) - ; h1*256*(h2*256 + l2) + l1*(h2*256 + l2) - ; h1*h2*256*256 + h1*l2*256 + h2*l1*256 + l1*l2 + ; h1l1 * h2l2 + ; (h1*256 + l1) * (h2*256 + l2) + ; h1*256*(h2*256 + l2) + l1*(h2*256 + l2) + ; h1*h2*256*256 + h1*l2*256 + h2*l1*256 + l1*l2 - ; l1 * l2 - imul8 result, arg1, arg2, xe ; 81-92 or 50-55 + imul8 result, arg1, arg2, xe - ; 256 * 256 * h1 * h2 - imul8 result + 2, arg1 + 1, arg2 + 1, xe ; 81-92 or 50-55 + imul8 result + 2, arg1 + 1, arg2 + 1, xe - ; 256 * h1 * l2 - imul8 inter, arg1 + 1, arg2, xe ; 81-92 or 50-55 - add16 result + 1, result + 1, inter ; 20 cyc - add_carry result + 3 ; 2-7 cyc + imul8 inter, arg1 + 1, arg2, xe + add16 result + 1, result + 1, inter + add_carry result + 3 - ; 256 * l1 * h2 - imul8 inter, arg1, arg2 + 1, xe ; 81-92 or 50-55 - add16 result + 1, result + 1, inter ; 20 cyc - add_carry result + 3 ; 2-7 cyc + imul8 inter, arg1, arg2 + 1, xe + add16 result + 1, result + 1, inter + add_carry result + 3 - ; In case of negative inputs, adjust high word - ; https://stackoverflow.com/a/28827013 - ; 10-50 cycles - lda arg1 + 1 ; 3 cyc - bpl arg1_pos ; 2 cyc - sub16 result + 2, result + 2, arg2 ; 20 cyc - arg1_pos: + ; In case of negative inputs, adjust high word + ; https://stackoverflow.com/a/28827013 + lda arg1 + 1 + bpl arg1_pos + sub16 result + 2, result + 2, arg2 +arg1_pos: + lda arg2 + 1 + bpl arg2_pos + sub16 result + 2, result + 2, arg1 +arg2_pos: - lda arg2 + 1 ; 3 cyc - bpl arg2_pos ; 2 cyc - sub16 result + 2, result + 2, arg1 ; 20 cyc - arg2_pos: - .endscope + rts ; 6 cyc .endmacro - -; min base: 19 * 2 + 81 + 22 * 2 = 163 -; max base: 19 * 2 + 92 + 27 * 2 = 184 -; min ext: 19 * 2 + 50 + 22 * 2 = 132 -; max ext: 19 * 2 + 55 + 27 * 2 = 147 -.macro sqr16_impl_inner result, arg, xe +.macro sqr16_impl xe .scope - inter = temp2 + arg = FR0 ; 16-bit arg (clobbered) + result = FR2 ; 32-bit result + ;inter = temp2 + inter = FR1 + + lda arg + 1 + bpl arg_pos + neg16 arg + arg_pos: + ; hl * hl ; (h*256 + l) * (h*256 + l) ; h*256*(h*256 + l) + l*(h*256 + l) ; h*h*256*256 + h*l*256 + h*l*256 + l*l - ; l * l - sqr8 result, arg ; 19 cyc + sqr8 result, arg - ; 256 * 256 * hl * hl - sqr8 result + 2, arg + 1 ; 19 cyc + sqr8 result + 2, arg + 1 - ; 2 * h * l * 256 - imul8 inter, arg + 1, arg, xe ; 81-92 / 50-55 cyc - add16 result + 1, result + 1, inter ; 20 cyc - add_carry result + 3 ; 2-7 cyc - add16 result + 1, result + 1, inter ; 20 cyc - add_carry result + 3 ; 2-7 cyc - .endscope -.endmacro + imul8 inter, arg + 1, arg, xe + add16 result + 1, result + 1, inter + add_carry result + 3 + add16 result + 1, result + 1, inter + add_carry result + 3 - -; min base ram: 5 + 163 + 3 = 171 -; max base ram: 7 + 184 + 18 = 209 -; min ext ram: 5 + 132 + 3 = 140 -; max ext ram: 7 + 147 + 18 = 172 -.macro sqr16_impl result, arg, xe - .scope - ; arg ; 16-bit arg - negated = FR1 - ; result ; 32-bit result - - ; 5-7 cycles - lda arg + 1 ; 3 cyc - bpl arg_pos ; 2 cyc - jmp arg_neg ; 3 cyc - - arg_pos: - sqr16_impl_inner result, arg, xe ; 163-184 / 132-147 cyc - jmp done ; 3 cyc - - arg_neg: - copy_neg16 negated, arg ; 18 cyc - sqr16_impl_inner result, negated, xe ; 163-184 / 132-147 cyc - - done: + rts ; 6 cyc .endscope .endmacro .proc imul16_func - imul16_impl FR2, FR0, FR1, 0 - rts + imul16_impl 0 .endproc .proc imul16xe_func - imul16_impl FR2, FR0, FR1, 1 - rts + imul16_impl 1 .endproc -;.proc sqr16_func -; sqr16_impl FR2, FR0, 0 -; rts -;.endproc +.proc sqr16_func + sqr16_impl 0 +.endproc -;.proc sqr16xe_func -; sqr16_impl FR2, FR0, 1 -; rts -;.endproc +.proc sqr16xe_func + sqr16_impl 1 +.endproc ; 11-27 cycles .macro round16 arg @@ -1051,6 +992,14 @@ common: ; zx_zy = 0 ; dist = 0 ; iter = 0 +; lda #00 +; ldx #(iter - zx + 1) +;initloop: +; sta zx - 1,x +; dex +; bne initloop +; sta z_buffer_start +; sta z_buffer_end lda #00 sta zx @@ -1148,11 +1097,16 @@ keep_going: shift_round_16 zy, 3 ; zx_2 = zx * zx +fixup_sqr16_1: + sqr16 zx_2, zx + 2 + ; zy_2 = zy * zy +fixup_sqr16_2: + sqr16 zy_2, zy + 2 + ; zx_zy = zx * zy -fixup_mandelbrot_hotspot: - jmp mandelbrot_hotspot -after_mandelbrot_hotspot: +fixup_imul16_1: + imul16 zx_zy, zx + 2, zy + 2 ; dist = zx_2 + zy_2 add32 dist, zx_2, zy_2 @@ -1248,27 +1202,6 @@ next: .endproc -.macro mandelbrot_hotspot_impl xe - ; zx_2 = zx * zx - sqr16_impl zx_2, zx + 2, xe - - ; zy_2 = zy * zy - sqr16_impl zy_2, zy + 2, xe - - ; zx_zy = zx * zy - imul16_impl zx_zy, zx + 2, zy + 2, xe - - jmp mandelbrot::after_mandelbrot_hotspot -.endmacro - -.proc mandelbrot_hotspot - mandelbrot_hotspot_impl 0 -.endproc - -.proc mandelbrot_hotspot_xe - mandelbrot_hotspot_impl 1 -.endproc - .macro scale_zoom dest ; clobbers X, flags .local cont @@ -1812,7 +1745,7 @@ zero_byte_loop: rts .endproc -.proc _mandel_start +.proc start jsr imul8xe_init @@ -2196,21 +2129,22 @@ init: sta imul16_func lda #.lobyte(imul16xe_func) sta imul16_func + 1 + sta mandelbrot::fixup_imul16_1 + imul16_patch_offset + 1 lda #.hibyte(imul16xe_func) sta imul16_func + 2 + sta mandelbrot::fixup_imul16_1 + imul16_patch_offset + 2 ; ditto for sqr16_func -> sqr16xe_func - ;lda #$4c ; 'jmp' opcode - ;sta sqr16_func - ;lda #.lobyte(sqr16xe_func) - ;sta sqr16_func + 1 - ;lda #.hibyte(sqr16xe_func) - ;sta sqr16_func + 2 - - lda #.lobyte(mandelbrot_hotspot_xe) - sta mandelbrot::fixup_mandelbrot_hotspot + 1 - lda #.hibyte(mandelbrot_hotspot_xe) - sta mandelbrot::fixup_mandelbrot_hotspot + 2 + lda #$4c ; 'jmp' opcode + sta sqr16_func + lda #.lobyte(sqr16xe_func) + sta sqr16_func + 1 + sta mandelbrot::fixup_sqr16_1 + sqr16_patch_offset + 1 + sta mandelbrot::fixup_sqr16_2 + sqr16_patch_offset + 1 + lda #.hibyte(sqr16xe_func) + sta sqr16_func + 2 + sta mandelbrot::fixup_sqr16_1 + sqr16_patch_offset + 2 + sta mandelbrot::fixup_sqr16_2 + sqr16_patch_offset + 2 ; create the lookup table