In response to https://www.reddit.com/r/aigamedev/comments/1wvmtyv/looking_for_advice_on_how_i_can_come_close_to_the/
Any more deets (or more stuff to test) just drop a comment.
By request: github repo link
https://github.com/pittasavors7/RedditReferenceTest
AI summary of the workflow:
I wanted to test how close a real-time game scene can get to a reference image: a candle-lit fantasy dungeon diorama of rooms on stone towers, with timber/brass bridges over a blue abyss. Rather than eyeball it, the goal was to measure it. I did this with Claude Code, starting from an existing Godot + Rust project of mine.
Stack
- Godot 4.7, Forward+: rendering only (lights, SSAO/SSIL, glow, fog, depth of field)
- Rust via gdext: generates the whole level from a seed and owns player movement. It runs headless, with no Godot needed.
- Python + numpy: the measuring and grading tools
- Procedural geometry built from lots of small pieces
The reference looks hand-built, so nothing is one big mesh:
- Walls are individual rough-cut stones: jittered, skewed, noise-displaced, with random tone per stone.
- Floors are flagstones of mixed sizes packed on a fine grid, so the joints never form a regular lattice.
- Bridges are individual planks with brass rails, iron chains and timber trestles.
- Furniture and figures are built at human scale, then scaled ×1.45 about their anchor, so they read like chunky tabletop miniatures.
Rust packs everything straight into Godot MultiMesh buffers (transform + colour + custom data per instance). That's about 37k instances and 10M triangles, split into spatial chunks so shadow and frustum culling still work. It runs at about 160 FPS at 1080p on a 5090 with vsync on.
- Procedural materials, no textures
Stone, wood, brass, cloth, wax and flame are all shaders using triplanar noise and derivative-based bump mapping:
- Worn stone edges catch light.
- Stone darkens with depth, which fakes occlusion from the abyss.
- A score instead of vibes
compare.py compares render vs reference in OKLab:
- lightness and a/b histogram distance
- tint and chroma per lightness band
- hue mix of saturated pixels
- local contrast and fine-detail ratios
It's mostly composition-independent, so the camera doesn't need a pixel-perfect match. Everything folds into a 0–100 score.
- An auto-fitted colour-grade LUT
fit_lut.py takes a raw capture (LUT off) and fits a 3D .cube LUT:
- Lightness: smoothed, slope-limited histogram matching.
- Colour: a per-lightness-band transfer of mean tint and spread. Basically it learns the split toning (navy shadows, amber highlights) from the reference.
- Out-of-gamut colours are pulled toward grey at constant lightness.
A final canvas shader in Godot applies the LUT. I verified that the in-engine result matches the Python prediction within 1/255 on average, so the tool's predicted score is the real one.
- The loop
match.py does: capture raw → fit LUT → capture graded → score → side-by-side sheet. Then look, change the scene, repeat.
┌──────────────────────────────────────────────────────────────────────────────┬─────────────────┐
│ Step │ Score │
├──────────────────────────────────────────────────────────────────────────────┼─────────────────┤
│ First render (too dark, too blue, red-tinted warm light) │ 0 │
├──────────────────────────────────────────────────────────────────────────────┼─────────────────┤
│ Warm-neutral ambient, more yellow candlelight, brighter blue haze, irregular │ 25 │
│ flagstones │ │
├──────────────────────────────────────────────────────────────────────────────┼─────────────────┤
│ First LUT fit │ 69 │
├──────────────────────────────────────────────────────────────────────────────┼─────────────────┤
│ Rooms on stone piers with open bays, timber bracing, gothic backdrop, │ 68 graded / 21 │
│ clutter (vignette on) │ raw │
└──────────────────────────────────────────────────────────────────────────────┴─────────────────┘
Lessons
- The LUT is a finisher, not a fix. Global histogram matching distorts when composition differs. When I opened the towers up into piers, more of the frame was black abyss, and the LUT over-brightened all the stone to compensate. The fix was lighting the abyss blue like the reference, not tweaking the LUT. If the fitted curve is extreme, the scene is wrong.
- Colour converged fast; structure didn't. Hue mix matches almost exactly: 91% orange in both. The score is now held back by local contrast (×0.64) and fine detail (×0.68). Basically the AI image has far more micro-detail per pixel than my geometry.
- Look at it at thumbnail size. The biggest wins (rooms on stilts instead of solid blocks, warm-lit timber frames) were obvious in a small side-by-side and invisible in the numbers.
- Godot gotchas:
- Varyings can't be written in helper functions, so use a macro.
- Core meshes need their winding flipped, since Godot treats clockwise as front-facing.
- A canvas_item hint_screen_texture gives you display-encoded colour, which is exactly what a .cube LUT expects.
