In January of 1995, Bryan Edewaard and I (Damien Jones) left our jobs in Dallas, Texas and moved to Florida to start our own business, temporary sanity designs. Our intent was to write a game for the PC - after all, since everybody else seemed to be doing such a lousy job of it, we could do it and maybe make a bit of cash in the process.
For several months we worked on a fast 3D polygon
engine, although without a final goal firmly in mind
we didn't get too far. (Then.) In April, we got the
idea that maybe we could do something for Atari's game
console, the Jaguar. This was Atari's attempt
to get back into the game console market - the market
they had once dominated with the Atari 2600.
Both Bryan and I had experience with Atari computers
in the past, and we were somewhat familiar with the
company.
The 2600
What we suggested to Atari was that maybe somebody should write an emulator for the Jaguar that would run the original games from the 2600 on the Jaguar - sort of like Activision's 2600 Action Pack for Windows. We suggested that that somebody be us. We told them one of us (Bryan) had already written a 6502 CPU emulator (for the Atari ST), so half the work was already done.
Atari seemed to like the idea, but they weren't too
sure about us. After all, when a company with
a name like temporary sanity designs sends
you a project proposal, asking for money and a free
development system (we sure couldn't afford
$8,000 for a Jaguar development kit), you're inclined
to treat the whole thing with a bit of skepticism.
They asked for a little "demonstration" that we could
produce something.
This presented something of a problem for us,
because while Bryan had written a 6502 CPU
emulator, he'd sort of, well, lost the source
code to it. We didn't have it, Atari wanted a demo
in fairly short order, and we didn't want to waste
a lot of development time writing a demo for Atari
computers that would be useless on the Jaguar. But
we did, in fact, produce a working demo of the game
Combat running on an Atari TT computer. It
wasn't 100%, but it was Combat.
Atari (or at least, the person we'd been dealing
with) was impressed. They sent out a Jaguar development
system on loan for sixty days. We had that long to
produce enough of a working demo to show that the
entire project was feasible. Keep in mind, neither
Bryan nor I had ever seen programming details for
the Jaguar (they're covered by NDA).
Not only had we never programmed the Jaguar before,
but writing an emulator is a difficult task.
(Our demo of Combat was, shall I say, very specific
to Combat.) One of the reasons an emulator is so
hard to write, particularly when dealing with the
2600, is that so much of the program has to be
fully working before you see anything
on the screen. Virtually the entire 6502 CPU
emulator, and a large part of the custom hardware
emulator, must be written and fully debugged before
anything intelligible appears.
To make things even more fun, the 2600 produces video
one scanline at a time. Computers of today produce
video one frame at a time. That is, even if
the CPU does absolutely nothing, the video
hardware will draw a full screen image. The CPU
only needs to get involved if there needs to be some
change from one frame to the next. The 2600
can only generate one line by itself. If
something is to be different between one screen line
and the next, the CPU needs to change data in the
video hardware. Because of this tight coupling
between the CPU and the display, the slightest
mistake in the CPU emulator immediately affects
what appears on the screen.
I mention this, only so you will understand how
technically difficult writing a 2600 emulator
is. We had a mere 60 days to produce "evidence"
that the project was feasible. Our work was definitely
cut out for us.
The Emulator
We started out by first learning the Jaguar system. To do this, we wrote a Julia fractal morpher, that generated real-time Julia fractals. (Kind of like our JuliaSaver program.) This took us through the weaknesses of the 68000 CPU, the RISC processors, the blitter, and the display processor. After three weeks, the Julia morpher was done, and we felt like we had learned a lot about the Jaguar. But that left us with only five weeks to do something about the emulator.
We put our nose to the grindstone, so to speak. We
cranked out an amazing amount of code. We discovered
technical difficulties - some that threatened the
viability of the entire project. We overcame. We
finished the 6502/6507 emulator, running on a
single RISC processor, a tiny 4K program, and it ran
faster than the 2600's CPU. To make it work,
we had to count cycles, trim instruction sizes, and
take massive shortcuts. I'm pretty sure we
could write the fastest 6502 emulator for almost any
platform, now.
But that was just the CPU emulator. We still had the
hardware emulator to do, and little more than a week
to go before our deadline. This was harder, because
not only did we have to deal with what hardware
was being accessed, but also when the program
accessed it. It was difficult, and we missed our
deadline by a week, but we had a 50% working
hardware emulator done. We had a display. We had
2600 games running on the Jaguar!
Relieved, we put the Julia morpher on the program as
a title screen, added a simple menu to let you choose
which game to run (Combat, Pac-Man, Yars' Revenge,
Adventure, Berzerk, and Defender), and sent it off to
Atari.
The Run-Around
They loved it. They really did. At first, they thought the Julia morpher was a compressed animation, like a QuickTime movie. We patiently explained that no, it was generated in real time, and if they twiddled with the console's controller, they could control it themselves.
Then our problems started. Although they liked the
demo, they didn't seem terribly interested in signing
a contract with us to finish the emulator. We later
learned that an Atari employee was working in-house on an
emulator of his own. Atari suggested if we had more
ideas for games, we should send them in. So we sort of
put the emulator on the back burner and looked around
for other ideas.
In producing the emulator and the Julia morpher, we
became quite aware of some of the limitations the Jaguar
had. The hardware was designed very explicitly to
produce Gouraud-shaded polygons and large numbers of
sprites. Although it could do texture-mapping, it
wasn't very good at it and could only do it slowly. We
focused on ideas that we thought the Jaguar could do
well. But whenever we submitted an idea to Atari, they
would delay for weeks before telling us "yes" or
"no". (They invariably said "no", of course.)
Without a contract, we were reluctant to work on any
serious Jaguar products, including the emulator. If
we had been writing for the PC, there would have been
other companies to sell the work to, but there weren't
too many companies in the Jaguar arena. And since the
2600 emulator sort of needed Atari's library of
games, it didn't make much sense to try to sell it to
somebody else.
We did produce a few other interesting little demos for
the Jaguar, though. Continuing along the fractal theme,
we produced a fast IFS fractal morpher and a Mandelbrot
generator. IFS fractals are the "fern" and related
types. We did two of these; one generated 4,096 IFS
points at about 20 frames per second (fps), and the
other generated 75,000+ IFS points at 8fps.
The Mandelbrot generator has a few interesting notes.
Along with the Jaguar development kit, Atari included
an example program which used the RISC processor to
generate an image of the Mandelbrot set, 256x200 to
256 iterations. This program ran in about eight seconds.
Our generator, using only one RISC processor, generated
a 320x480 image to 256 iterations in five seconds,
and we could have easily used both RISC chips.
(Atari's code could only use one.)
One other thing we did was interlacing. The Jaguar
hardware is supposed to support an interlaced
display. Atari even claimed this in their advertising
material. Developers, though, were told not to
use interlacing, and the information on how to use it
was removed from Jaguar programming material. Apparently,
there was some difficulty in the interlace hardware; it
generated "ugly color bars" or some such. Not knowing
this (we somehow missed the prohibition) we wrote interlace
code anyway, which didn't exhibit any artifacts. At first,
Atari people refused to admit our demo was using
interlacing. They thought we were doing something else
that only looked like interlacing. When we told
them how our demo worked, they grudgingly admitted
we were doing interlacing - and then refused to admit that
it worked.
We continued talking with Atari, sending them project
ideas, for almost six months. Our contact person left
Atari (we don't think it was directly related to us) and
we never seemed to get anywhere after that. It
always seemed like we were just a week away from having
a contract... Finally, in January of 1997, after they'd
laid off almost everyone, they told us they were not
accepting any new contracts.
Hope
At this point we weren't really sure what to do, so we sort of fumbled around a bit, kind of half-heartedly working on our long-forgotten polygon engine. But then an old acquaintence dropped by on vacation and talked to us about a project he was thinking of doing. We liked the idea, and we didn't have anything promising of our own (after a couple of months of looking), so we agreed. And that's basically what we've been doing since February of 1996. It's our big secret project that we can't talk about (yet). But it's almost ready for release.
