SpritesMind.Net

Hello everyone. I haven't been active here for.. a long time. I just started working on a small Sega CD program (Yes, this is the Genesis forum but the problem I'm about to talk about has to do with the main M68K processor and nothing involving SCD hardware)
So I've created a simple system for showing animated sprites I have an array-like structure with each entry containing fixed point position,velocity and acceleration values. (lowest 6 bits are the fractional part)
I have this sprite that acts like a bouncing ball. It has a constant positive vertical acceleration value so it accelerates downwards (unless A,B,C are being pressed, in which case it accelerates upwards).
So, to make this sprite bounce I set the velocity this way every time the sprite touches a lower limit and then I change its sign:
VerticalAcc=VerticalAcc *4/3

In 68K asm and assuming d3 is the vertical acceleration (again, a 16 bit value whose lower 6 bits correspond to the fractional part) While stepping with Gens debugger I noticed that the signed division of a negative value produces an invalid result
Let's say d3 is -7 ($FFF9 in two's complement)
doing for some reason, stores into the d3 register $00017FFC (highest two bytes are the remainder and lowest two bytes are the quotient), which is funny because DIVU yields the same result.
According to the 68k reference the result should be $FFFFFFFD (remainder -1,quotient -3)

For DIVS, the sign of the remainder is always the same
as the sign of the dividend (unless the remainder is zero).

So yeah that's pretty much it? What could it be? Both Gens and Fusion produce the same result.. I couldn't test it on real hardware.

Your problem is your dividend is a LONG, but you're loading a WORD. Sign extend that MF!!


And don't use divide on powers of two - use the arithmetic shift instead (unless you need the remainder).

Chilly Willy you are AWESOME! That was it! Apparently the manual I've been reading doesn't mention that (http://courses.ece.ubc.c/259/Summary%20 ... %20Set.pdf Page 21 doesn't mention that). From now on I'll just stick to the "M68000 Family Programmer's Reference Manual"
Thank you

PS: I wasn't familiar with the concept of sign extension so thanks for that too

No problem. It's easy to miss simple things, especially if the manual doesn't point it out. Those make the most "fun" kind of bugs because it IS so simple to miss.

Chilly Willy wrote: And don't use divide on powers of two - use the arithmetic shift instead (unless you need the remainder).

If you need the remainder, you use a logical "and"

tryphon wrote:

Chilly Willy wrote: And don't use divide on powers of two - use the arithmetic shift instead (unless you need the remainder).

If you need the remainder, you use a logical "and"

Well, you also need to worry about the sign, but that's certainly still faster than the mega-slow divide on the 68000.

Chilly Willy wrote:

tryphon wrote:

Chilly Willy wrote: And don't use divide on powers of two - use the arithmetic shift instead (unless you need the remainder).

If you need the remainder, you use a logical "and"

Well, you also need to worry about the sign, but that's certainly still faster than the mega-slow divide on the 68000.

Is it really that slow? What would be the other way to do it? I'm thinking of negating the number only if it's already negative, do the shifting, and negating it back into a negative number.(EDIT: I'd written positive, oops)

Here is VERY GOOD LINK.
http://oldwww.nvg.ntnu.no/amiga/MC680x0 ... iming.HTML
I save it into bookmarks
It's all about "what is slower" and how much.

RamiroR wrote:

Chilly Willy wrote:

tryphon wrote: If you need the remainder, you use a logical "and"

Well, you also need to worry about the sign, but that's certainly still faster than the mega-slow divide on the 68000.

Is it really that slow? What would be the other way to do it? I'm thinking of negating the number only if it's already negative, do the shifting, and negating it back into a positive number.

That's probably the fastest way to handle it, and will be much faster than divide for certain.

You can divide a signed number by a power of 2 in this way.

Signed division:
Signed remainder: