Why were 3D games on the Amiga not faster than on similar 16 bit systems like the Atari ST

Question

It seems that 3D games, especially simulations like Falcon, were not faster (fps) on the Amiga than on the Atari ST - even a bit slower due to the CPU clock.

I was wondering why this is the case, since the Agnus seems to me as an early model of a GPU, capable of drawing vector lines and even fill out polygons. Was it not capable to display the typical number of 3D objects in those games or was it simply not used, since it would require a complete different codeline for the Amiga with respect to 3D rendering ?

Answer 1

There are a few reasons why multi-platform 3D games turned out to be no faster on the Amiga than on other 68000-based platforms without its blitter:

The developers may have targetted the lowest common denominator system and not taken advantage of the blitter when they ported to the Amiga. Early games and poor conversions tended to be like this.

A naive implementation by somebody unfamiliar with the hardware may well fail to use the blitter's line-drawing and space-filling operations efficiently, thus losing the benefit. If one draws and fills individual polygons and then blits them to the framebuffer, that is a lot of wasteful work. AmigaOS itself didn't set a good example here.

Finally, the blitter is a pure 2D device which offers no acceleration for 3D calculations, so the main CPU needs to do those. This involves a lot of matrix multiplication, and the 68000's MULU/MULS instructions are very slow, taking about 70 cycles. (The exact number of cycles is data-dependent because the microcode uses an iterative algorithm.) At 7.09MHz that's a shade over 100,000 multiplies per second, or 2,000 per 50Hz field. Even if the blitter was infinitely-fast, this still sets an upper limit of a few hundred points on screen or compromise on frame rate.

Answer 2

The thing the Agnus has that speeds up 3D games is the polygon fill feature. Blitting by itself is not so much a standard operation driving 3D performance. It can help 2D games and windowed GUIs a lot, however, one of the reasons the Atari ST got a (much simpler) blitter as well in later releases.

3D Games are CPU-heavy, or rather performance is driven how fast you can do vector arithmetics and trigonometric functions (which would mainly be done by table lookups in older games) - Agnus doesn't help here, even a 68881 wouldn't help much, as fixed-point integer maths done by a 68k are still faster. We're talking mainly integer operations here, and that is driven by raw CPU speed and bus contention.

Answer 3

Agnes doesn't help much with 3D acceleration. It has a blitter which is capable of filling polygons, but they must then be copied in to the display bitmap so it's actually slower than just filling with the CPU. Additionally the blitter requires the horizontal limits of the polygon to be rendered first, meaning an additional line draw per vertex.

The biggest performance limitation for 3D on the Amiga is memory bandwidth. In fact all 16 bit home machines of the time were the same, memory bandwidth was the biggest challenge.

The maximum fill rate can be achieved by using unrolled CPU loops that write directly in to bitmaps. There is then no copy stage, and no need to line draw vertexes.

The general strategy used by most high performance 3D on the Amiga is to calculate all vectors in one go, allowing as much data to be kept in CPU registers to avoid memory reads. The display is then rendered by the CPU alone as outlined above.

Since the Amiga had the same CPU as the Atari ST running at a similar speed, but with actually a little bit less memory bandwidth performance was about the same. The Amiga could do some tricks to improve things, such as variable colour depth on different parts of the screen and sprites for low overhead overlays, but in practice they tended not to be that significant performance-wise.

Answer 4

I did 3d on both and optimizations were different on both machines; I didn't do very advanced stuff at the time, mostly rotating simple objects, etc but no game or complex scenes.

On the Amiga, you would use the blitter to draw lines and fill the bitplanes. The different bit planes were not interleaved but sequential, so the size of the blitter pass you had to do was depending on the colors used. You would draw the same lines in all the planes needed and then do a blitter fill, but filling plane 0 and plane 3 in two passes was slower than filling plane 0 and 1 in a single pass which was slower than filling only plane 1 for example.

The blitter really sped up the filling, but the bitplane layout forced color palette organization in order to make sure the largest surfaces of your objects were the fastest to fill.

On the Atari ST, it was a different story: you had to draw your picture as you were building your triangles, so you needed to sort the vertices vertically and then, as you were doing line interpolations, you were filling up the screen. The edges were tricky to work with, but large surfaces could be filled in a single pass.

In short, the ST required more CPU work, but drawing the picture could be done in a single pass. On the Amiga, the process was generally faster, but the memory layout generated a lot more memory traffic.

Despite these differences, the two came remarkably close in performance.

Answer 5

It's because of the particular things each system was best at, and could better accelerate. 3D games were actually one of the few cases (plus a few other number-crunching sims?) where games ran faster (not just "at the same speed") on the ST rather than the Amiga. And it's entirely because of the reason you first posit; the Atari had an ~11% faster CPU clock.

The games in question were very heavily CPU-bound, their simulation, and their drawing as well, relied almost entirely upon numeric calculation (and getting stuff in and out of RAM, which was also faster). The actual moving-data-to-the-screenbuffer part was a relatively small piece of the whole setup; I daresay that the Amiga's custom chipset still made that operation somewhat faster than the same job in the ST, at least what parts of the job it was actually capable of accelerating (it's not really much of a GPU; it's pretty much just a console style hardware-sprite-and-scroll engine, with a few fancy tricks like line-by-line auto-fill which helps a bit with rendering solid polygons if the programmer knows how to / can be bothered making use of it, or the register bit-banging provided by the Copper), but the ST was already entirely capable of shoving the calculated and rendered output to the screen pretty much as fast as it was produced (by double buffering, so the final "painting" of the screen was a single register-write), so the best it could have done was maybe shave one scan-time off the construction and display of each frame.

There's no line or box or other primitive drawing acceleration, no large-area auto fill, no bezier curves, absolutely nothing that would count as even the most rudimentary 3D acceleration, the sprites or second playfield only appear as overlays (and for the most part are irrelevant here, other than PF2 being used as a cockpit/HUD for a fairly minor speedup), hardware scrolling is pretty much useless, as are most Copper tricks, and even the (less efficient than the ST's - assuming the Atari had one fitted of course) Blitter is of limited usefulness.

If the complexity of the scene was such that it took the Amiga CPU fully 8 scans to finish computing and rendering the image, but the ST only needed 7 (entirely plausible given that a lot of 3D polygon games really struggled to do any better than maybe 6~7fps, which is a 7 to 8 "frameskip" on a PAL monitor, and worse on NTSC), then even that minor improvement to the rest of the system latency wouldn't do anything more than bring them back to level-pegging.

Pretty much any other type of contemporary game, sure, the Amiga had it comfortably in the bag. But for sims and other 3D stuff, the ST just about nosed ahead.