While doing some preliminary interview footage for the Arcade Documentary project, I asked a bunch of teenagers what most surprised them at the MAGFest pop-up arcade, where dozens of games of all stripe were right there ready to be played. To a person, it was one thing:

The vector monitor on Asteroids.

If you see Asteroids online, the “screen” probably looks like this:

That is, it’s a JPEG or PNG or whatever, with the source likely being an emulator of some sort. So everything is crisp, and rasterized, and generated as if were a screen map, that is, from the assumption that it’s a raster screen. Playing the emulator itself is similar – there it is on your recently-vintaged flatscreen, perfectly sharp, definitely of the modern desktop era.

When you see it in the arcade, an original Asteroids machine screen looks kind of like this:

The vector lines, which are created by aiming a beam DIRECTLY AT YOUR EYES only to be stopped by a coated piece of glass, have a completely different feel. The phosphor glows, the shots look like small stars floating across the glass, and a raster line is not to be seen. It’s an entirely different experience, and the teenagers at MAGfest had never seen it before, and unfortunately, it is well on its way out.

(It would be worth it for myself or someone else to do research into “so what is the deal with CRT and vector monitors these days”. Some other time.)

So there’s several ways to go about this “problem”, assuming you recognize it as a “problem” that various types of monitors are disappearing with great speed, every year. One is to hoard old monitors. This is short-sighted and doomed. Another is to forget those monitors never existed. On the plus side, not much energy is required to do that. But these monitors are worth remembering, and it’s certainly the case that the software was written with these old display devices in mind.

Enter geekery.

Originally, emulators were trying to adapt this old software to be useful or at least pretty to modern systems – so the efforts were around scaling and smoothing. I can’t find the at-arms’-reach citation for when this started, but it’s at least a decade old. You could choose to smooth, upscale and anti-alias the graphics for your now-kickass setup, historically wrecking the item, but making it a lot easier to look at. (If you want an earlier situation that’s the same, there’s the adventure of DOOM and OpenGL.)

But meanwhile, CRTs started falling out of favor in a big way, and slightly rounded glass screens and beige enclosures began falling in front of Plasma and LCD.

Ian Bogost used slave student labor and created a Television Simulator to work out some themes in the excellent Racing the Beam book about the Atari 2600’s programming and context. It really opens your eyes to see the difference between the “original” emulated image and the “CRT simulated” graphics:

Suddenly, it’s pretty clear how the perfection of emulation takes away a lot of the analog fog that made digital compelling in a certain way.

Now, not unexpectedly, people were not happy with this implementation, since it wasn’t perfect and it wasn’t flexible. So work continued.

Some time ago, I was shown this image in relation to efforts with simulating a CRT monitor:

We’re getting into the Twilight Zone of Maybe You Don’t See All This Shit Going On, and that’s entirely fine. For some folks, the binary situation of “I can see it / I can not see it” is quite enough – that things are emulated at all is the end of the story. But still, it is quite amazing to me to see such subtle aspects as the curve of the monitor, the glow of pixels against glass, and the bleeding of voltages and scan lines all being emulated in software (sometimes with graphics hardware doing some of the lifting). In fact, working this hard to make these graphics look slightly ‘bad’ is a ton of work.

There’s a bunch of advancement being done with this outlook, using the MAME and MESS emulators. The direct name for this particular project is HLSLMAME. There’s a thread of discussion here about it. (There’s another thread over here as well.)

The images of the screenshots have a haunting quality to them, old but not old. Perfect but imperfect. I really love looking at them.

For an extra bonus, I was sent a few videos of this software CRT emulation in action.

I’ve uploaded them to the Internet Archive, where you can check them out. While you can play them on the Internet Archive’s player, I would not recommend this – all the subtle changes to the video signal are just not as obvious through the compression. Pull down these tens-of-megabytes files and see the changes in the video look through the settings.

When you look at the example configuration files, you realize how much of a tweaker’s paradise this is:

hlsl_enable 1 hlslini %g hlsl_prescale_x 4 hlsl_prescale_y 4 hlsl_preset -1 hlsl_write hlsl_snap_width 2560 hlsl_snap_height 2048 shadow_mask_alpha 0.00 shadow_mask_texture aperture.png shadow_mask_x_count 320 shadow_mask_y_count 256 shadow_mask_usize 0.187500 shadow_mask_vsize 0.09375 curvature 0.02 pincushion 0.02 scanline_alpha 0.450000 scanline_size 1.25 scanline_height 0.750000 scanline_bright_scale 1.000000 scanline_bright_offset 0.750000 scanline_jitter 0.25 defocus 1.0,1.0 converge_x 0.0,0.0,0.0

...

….and so on. SO MUCH TWEAKING AND KNOBS. But it’s from this we can get some amazingly refined experiences and ideas.

This HLSLMAME thing is currently Windows only, and it’s a little involved to get running, but the point remains the same: this is valuable work, affecting perceptions of the software after its true mechanical components are gone off the earth.

There’s plenty of other aspects awaiting this effort, too: the sounds, the ambience, the buzzing of speakers and the hum of deflection coils. There’s been attempts to make controllers that act like the originals, and there’s always been some leaning towards getting the speed just exactly right, which is harder than it seems.

In all this, it’s the not wanting to lose something than many don’t even notice is lost that’s the critical move. It’s sometimes a bit too OCD and always a little annoying if it’s not that important to you, but realizing what, exactly, has changed for software makes bringing it back that much more likely. It’s a respect for the past beyond the idea of it. It’s messy and weird and geeky but that’s just the way I like it.

Here’s to terrible monitors!

thanks to DFJustin for his assistance

the lion’s share of programming of HLSLMAME is by Ryan Holtz / MooglyGuy

Share this: Share

Email

Facebook



Reddit

Twitter





Categorised as: computer history

Comments are disabled on this post