Atan2 in assembler for "integer" / screen-ish coordinates

[morbid]

If you make sure your dx and dy are between -128 and 127, and have lots of memory you could do something like:

; d0 = dy
; d1 = dx
; a0 = pointer to middle of table with high byte
; a1 = pointer to middle of table with low byte
; result in d2
lsl.w #8,d0
move.b d1,d0
move.b (a0,d0.w),d2
lsl.w #8,d2
move.b (a1,d0.w),d2

[Rotschi]

I do not know if it is of interest for you, but you could also try to eliminate the divu in your posted code by simply replacing the division with a multiplication of the reciprocal (catchword: lut).

[dansalvato]

Here is my atan2 function: https://gist.github.com/dansalvato/7...59eca30583716e

; atan2: Returns the angle from origin to the given XY coordinate.
; Angle is from 0-255 (assume a 256-degree circle).
; d0: X value
; d1: Y value
atan2:
            moveq       #32,d3
            tst.w       d0
            blt         .xneg
.xpos:      tst.w       d1
            blt         .quad4
.quad1:     moveq       #0,d2
            bra         .0
.xneg:      tst.w       d1
            blt         .quad3
.quad2:     moveq       #64,d2
            neg.w       d0
            exg         d0,d1
            bra         .0
.quad3:     moveq       #-128,d2
            neg.w       d0
            neg.w       d1
            bra         .0
.quad4:     moveq       #-64,d2
            neg.w       d1
            exg         d0,d1
.0:         cmp.w       d3,d0
            blo         .1
.0b:        lsr.w       #1,d0
            lsr.w       #1,d1
            cmp.w       d3,d0
            bhs         .0b
.1:         cmp.w       d3,d1
            blo         .2
.1b:        lsr.w       #1,d0
            lsr.w       #1,d1
            cmp.w       d3,d1
            bhs         .1b
.2:         lsl.w       #5,d1
            add.w       d0,d1
            add.b       AtanTable(pc,d1.w),d2
            move.l      d2,d0
            rts

Feature breakdown:

• No divides
• No use of address registers
• 256-degree circle
• 1,024 byte lookup table (32x32), 8-bit table entries
• Return value is longword signed

It balances speed, accuracy, and memory usage—not highly optimized for one specific metric. The lookup table is for one quadrant of the circle, which is "mirrored" depending on the sign of the coordinates.

There is a loop to shift the XY coordinates down to <32 each, which can probably be made slightly more efficient. For the time being, it's good enough for my purposes.

The whole function takes 136-146 cycles (including rts) depending on quadrant, plus ~32 cycles for each shift required to reach <32 on the larger value.

[PaulF]

Originally Posted by dansalvato

Here is my atan2 function: https://gist.github.com/dansalvato/7...59eca30583716e

; atan2: Returns the angle from origin to the given XY coordinate.
; Angle is from 0-255 (assume a 256-degree circle).
; d0: X value
; d1: Y value
atan2:
            moveq       #32,d3
            tst.w       d0
            blt         .xneg
.xpos:      tst.w       d1
            blt         .quad4
.quad1:     moveq       #0,d2
            bra         .0
.xneg:      tst.w       d1
            blt         .quad3
.quad2:     moveq       #64,d2
            neg.w       d0
            exg         d0,d1
            bra         .0
.quad3:     moveq       #-128,d2
            neg.w       d0
            neg.w       d1
            bra         .0
.quad4:     moveq       #-64,d2
            neg.w       d1
            exg         d0,d1
.0:         cmp.w       d3,d0
            blo         .1
.0b:        lsr.w       #1,d0
            lsr.w       #1,d1
            cmp.w       d3,d0
            bhs         .0b
.1:         cmp.w       d3,d1
            blo         .2
.1b:        lsr.w       #1,d0
            lsr.w       #1,d1
            cmp.w       d3,d1
            bhs         .1b
.2:         lsl.w       #5,d1
            add.w       d0,d1
            add.b       AtanTable(pc,d1.w),d2
            move.l      d2,d0
            rts

Feature breakdown:

• No divides
• No use of address registers
• 256-degree circle
• 1,024 byte lookup table (32x32), 8-bit table entries
• Return value is longword signed

It balances speed, accuracy, and memory usage—not highly optimized for one specific metric. The lookup table is for one quadrant of the circle, which is "mirrored" depending on the sign of the coordinates.

There is a loop to shift the XY coordinates down to <32 each, which can probably be made slightly more efficient. For the time being, it's good enough for my purposes.

The whole function takes 136-146 cycles (including rts) depending on quadrant, plus ~32 cycles for each shift required to reach <32 on the larger value.

That's great. Thankyou.