more about tsd

You must be tremendously bored... if you'd like to see even more useless stuff, try the Useless Web Pages index.

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.

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.

[  About TSD page  ]

Copyright © 1997 Temporary Sanity Designs