It took a couple of hours to get the framebuffer addressing correct (the UCG uses block-primary tiling rather than row-primary, but it's reported misleadingly in the system) and dial in the resolution and down-scaling sampler (default DOOM runs at 320 x 200, but had to get it to 80 x 50 to fit the whole screen, then play with sampling to get the important bits to show up rather than just all-ceiling all-the-time), but there it is. Real, 100% running DOOM on a UCG-Ultra.

Currently only running in Attract mode — since there's a lack of physical buttons, controls aren't going to be as straightforward as they are on some other devices. I'm looking at options to do something cool with system stats or network traffic as a control mechanism.

# Technical Details:

Overall, it was almost disappointingly easy. The display is controlled by a standard Sitronix ST7735 connected on spi1.0 and pulling frames from `/dev/fb0` and reporting:
```
x_res=160
y_res=80
bpp=16
line_length=320
screensize=25600
```

The panel does *not* use linear addressing, which caused some initial hiccups with ghosting and tearing. This caused some delays, because the kernel `fbdev` *pretends* that it is, but several stripe-tests confirmed that the actual GRAM layout is 5 16-row tile-organized vertical blocks that write to output when the last row is filled. Writing to the framebuffer with `fb[y * stride + x]` solved that issue.

Next challenge was scaling. DoomGeneric (I know, that's kind of cheating) renders internally at 320 x 200. I didn't feel like rewriting the entire DOOM engine, so downscaling it is! Initially, I thought I could save myself a headache and just draw every other row, but that messed with the internal rendering so I got 90% sky and none of the important viewport. 

The solution ended up being a careful crop that removed the least important parts of the screen and focused the bits where the action happened: 
```
SRC_CROP_Y0=30
SRC_CROP_H=140
VIEW_X_OFFSET=40
VIEW_Y_OFFSET=15
```
That removed the top 30 pixels (all sky/ceiling) and then took the next 140 pixels and centered them as the view. A basic nearest-neighbor sample made a clean output so I didn't bother pursuing any more advanced downsampling algos. Especially since I haven't touched C since high school. 

Rendering it all by physical block rows rather DOOM rows solved the last of the artifacting. And there it is! The whole thing lives in `/root/` userspace so it shouldn't break any functionality. 

In theory, I could plug this up to my network and have it route traffic while playing DOOM, though I'm not sure how it would affect throughput. My guess is not great, but not terrible: DOOM is stupidly low-resource and can literally be played on a potato, but on the other hand the UCG-Ultra is also stupidly underpowered and already struggles to keep up with real-world use in anything but the most basic deployments. 

# Next Steps: 

Get controls working. There are no physical exterior buttons, so controlling the action will need an external control surface. I'm trying to think of some cool network-related option that can control the action in a way that doesn't leave it completely useless (e.g. navigating to different screens in the UI won't work as it's too slow to be useful).

**tl;dr -** I got DOOM running on my spare UCG-Ultra, AMA.

Had a spare UCG-Ultra and some time to kill...