PerthThe worklog
An open-world game, built in the open
Credits & data

On the workbench

Updated 22 Nov 2026 · 17 entries in three lanes

An open-world crime game set in a fictionalised 1990s Perth, Western Australia, on a custom fork of the Godot engine. This is the working record: what was built, what was measured, and what is still wrong.

Code

Engine, streaming, scripting, tools

Newest first7 entries
Milestone

Five kilometres of the centre: 1,627 cells, median 1.41 ms, and 49 hitches

Over the east end of the centre at 216 m. Building footprints raised to their heights as plain blocks; ground, roads and water from open data.
Over the east end of the centre at 216 m. Building footprints raised to their heights as plain blocks; ground, roads and water from open data.

The area is five kilometres square around the centre of Perth, the river and Kings Park: 1,627 cells, plus 629 coarse cells in five levels for the far view. The bake takes 45 seconds and the world is 394 MB on disk.

An automatic flight at 62 m/s, 269 seconds, 16.7 km, on an RTX 5060 Ti at 1028 x 744:

Frames188,027
Median frame1.41 ms
95th / 99th percentile1.98 / 2.43 ms
Longest frame277 ms
Frames over 16.7 ms49
Most in view in one frame79 pages, 2,031 instances, 9,724 clusters
Entered a cell without collision0
Pages refused, instances dropped or diverted0
Read from disk350 MiB (733 MiB after decompression)

The median says the steady state is cheap. The 49 slow frames say the arrival of new content is not yet smooth: they come when a batch of pages lands together and the renderer makes their mesh buffers on the main thread. In 18 ticks the mount phase went over its 1,000 µs budget, the longest taking 13.8 ms. The streamer's bookkeeping without mounting never took more than 0.54 ms.

Collision held: 495 collision mounts, the longest 196 µs, and the camera never entered a cell whose collision was not there.

As a check on scale, a stand-in world of 28,224 cells (the Greenwood kilometre tiled) bakes in 6 minutes to 6.1 GB and flies at 100 m/s.

The freeway interchange west of the centre, with Kings Park behind.
The freeway interchange west of the centre, with Kings Park behind.
Inner suburbs north of the centre: 1,073 instances in view from 46 pages.
Inner suburbs north of the centre: 1,073 instances in view from 46 pages.
Low among the towers. These are extruded footprints, not models.
Low among the towers. These are extruded footprints, not models.

49 frames of 188,027 were over 16.7 ms, 33 of them over 33.4 ms, and the longest was 277 ms. The goal is none. Six pages missed their deadline at the cold start. Tunnels leave gaps in roads, and the river bed and sea floor are not written at all: the water is a flat sheet.

Next: keep the making of mesh buffers inside the mount budget, then fly the whole 21 x 23 km area.

Milestone

The first streamed square kilometre

Greenwood, a northern suburb of Perth, streamed from disk at 62 m/s. The overlay is the streamer's own debug view. Stand-in buildings and trees.
Greenwood, a northern suburb of Perth, streamed from disk at 62 m/s. The overlay is the streamer's own debug view. Stand-in buildings and trees.

The square kilometre of suburb that was generated for the size count now goes through the real baker, is mounted by the real streamer, and can be flown over.

It is 64 cells. The generator writes what the baker reads: placements, meshes and rasters, one file for each cell. The baker makes the pages and the coarse levels; the streamer mounts them as the camera moves.

An automatic flight at 62 m/s (the cruise of a light aircraft), 86 seconds, 5.3 km, on an RTX 5060 Ti at 1028 x 744:

Frames67,320
Median frame1.15 ms
95th / 99th percentile1.95 / 3.42 ms
Longest frame36.6 ms
Most in view in one frame28 pages, 3,393 instances, 4,461 clusters
Entered a cell without collision0
Pages refused, instances dropped0
Read from disk75 MB

One change in the engine came out of it: a mesh's clusters are now built on the worker that loads it, not on the main thread.

The same flight, lower. 28 visual pages and 2,555 instances in view.
The same flight, lower. 28 visual pages and 2,555 instances in view.

12 frames of 67,320 were over 16.7 ms; the longest was 36.6 ms. A handful of pages missed their deadlines at the cold start, four of them collision.

Built

Texture formats: Basis Universal 2.50 and ASTC 6x6

Textures are most of what a game puts on disk, so the engine's texture path was brought up to date before any real textures exist.

  • Basis Universal 1.60 to 2.50. The packer can now choose UASTC (still the default, and the one to iterate with), XUASTC, ASTC or XUBC7, in block sizes from 4x4 to 12x12. Textures imported with 1.60 load without a reimport, to the same bytes.
  • ASTC 6x6 as an image format, an import option and a project default. Automatic block size is 6x6 for colour and single-channel data and 4x4 for normal maps.
  • Transcoding by policy. A file becomes ASTC of its own block size where the device takes it, and BC7, BC3, ETC2 or uncompressed data otherwise. A device that supports both families gets its platform's own.
  • A memory gate on encodes. XUASTC needs 5 GB to encode one 2K texture at 4x4. Six textures imported together peaked at 9.0 GB without the gate and 6.5 GB with an 8 GB budget.

Two faults found on the way: uploads of an ASTC 6x6 texture larger than one update region failed, because regions are a power of two and no 6x6 block divides one; and the decoder refused a mipmapped image whose size is not a power of two.

The earlier comparison had concluded that 2.50 was not worth taking for the codec alone: it buys smaller downloads at a large encoder cost. The upgrade was done all the same, and it adds the larger block sizes.

The importer cannot tell an albedo from a packed mask, so channel weights are equal. The texture budget for the whole game is still an assumption, not a measurement.

Measured

Collision is baked for each cell and attached in microseconds

Collision for a cell is one Box3D compound, baked offline. At run time it is loaded from bytes and checked on a worker thread, then attached on the physics thread as one body in one step.

1,000 instances3,00010,000
Compound: children, size126, 102 KiB376, 296 KiB1,251, 976 KiB
Check on a worker3 µs5 to 7 µs32 to 41 µs
Attach, mean / longest2 to 3 µs / 26 µs3 to 5 µs / 27 µs5 to 6 µs / 25 µs
Detach, mean / longest1 µs / 6 µs1 to 2 µs / 6 µs2 µs / 11 µs

Attaching does not grow with what is in the cell. In the test, 200 balls were dropped on each cell while cells came and went; none went through the ground. In the largest cell two rolled off the edge in ten seconds, which the test now tells apart from falling through.

One caution about our own numbers: the physics step timings taken alongside were measured in an order that makes them unreliable, so they are not quoted here. The attach and detach times are direct.

On disk, a baked Box3D triangle costs 43 bytes and a box about 108. That turned out to matter more than expected: see the measured cell of suburb.

Never tried under a car. The test cells are 128 ground triangles and boxes; a cell of real triangle meshes is larger and was not attached in this test.

Measured

A page of instances mounts in one step: about 20 µs

The first version of the streamer replayed a cell one placement at a time: an engine instance, an entry in the culler's tree and several calls for every object. At 200 km/h a city needs something like ten thousand new instances a second, so that could not stay.

Now a visual page is a block of 52-byte records that goes to the GPU as it is. The visibility buffer culls, draws and shades the records in the main view, in shadow passes and in reflection probes. Mounting makes no engine instance, puts nothing in the culler, and makes no call for a record.

Measured on an RTX 5060 Ti:

Instances in the cellMount, old pathMount, pagesUnmount, old pathUnmount, pages
1,0001.9 msabout 20 µs5 ms8 µs
3,0008.0 msabout 20 µs26 ms8 µs
10,00022 msabout 20 µs106 ms8 µs

The cost on the main thread no longer grows with what is in the cell, which was the requirement. A drive at 56 m/s and a flight at 100 m/s over a made-up world had no frame over 9.2 ms at any of the three sizes.

The renderer skips a whole page whose bounds are outside the view; inside a page the GPU culls and picks detail for each cluster, as it already did.

A page instance must be opaque and static. Anything alpha-tested, transparent or with moving vertices is diverted to the slow path, one record at a time. A view holds at most 262,144 page instances.

Built

GameMonkey Script for the game's scripts: a register VM, threads, update rates

The game's scripts are written in GameMonkey Script, a small language from 2002 by Matthew Riek and Greg Douglas (MIT), instead of GDScript. The language is taken, not the code: the parser, compiler and virtual machine are new, and every script value is the engine's own Variant, so nothing is converted when a script calls the engine or the engine calls a script.

Why this language: its threads. A mission is a thread that can sleep, block on a signal and be ended from outside, and the whole script state can be saved and restored as bytes.

What is built:

  • A parser, a compiler and a register VM.
  • Threads: thread, yield, sleep, block, signal, fork, states, and a scheduler with a budget for each frame.
  • The engine binding: .gm scripts on nodes, calls into any engine class, engine signals queued to the tick.
  • Optional type annotations with a checker and typed instructions.
  • Tools: breakpoints, stepping, a view of every thread, a profiler, hot reload, completion.
  • A game layer: missions that own what they make, tickets with deadlines, snapshots, save and load.

Update rates

A polling thread can be given a period and a phase, both in ticks. Phases are handed out in turn, so 150 threads at period 15 are 10 a tick, not 150 on every fifteenth tick. Nothing looks at the clock, so a replay or a restored save runs the same way.

Measured against GDScript

Milliseconds, best of 35, GDScript written as a GDScript programmer writes it:

ProgramGameMonkey typedGDScript typed
fib(27)34.265.9
Float loop, 3 million13.148.7
Table fields, 2 million33.8340.4
Member variables, 2 million36.424.8
A* on a 40 x 40 grid78.6162.2
3,000 nodes moved, 100 frames47.260.7
48 workers waiting and answering42.7401.1

An earlier claim, "faster than typed GDScript on all nine programs", was true only against GDScript written with while loops. Written with for i in n, GDScript gains a third to a half, and the table above is against that form.

GDScript is still faster at member variables (24.8 ms against 36.4). The benchmark machine was not idle. The editor tools were exercised without a display. No game system uses the mission layer yet.

Design

The world streamer: square cells, and deadlines in seconds

The streamer's job is stated as throughput: a car at 200 km/h, and an aircraft after it, must never see or touch anything that is not loaded, and the frame must not notice the loading.

The design, as approved:

  • Square cells of 128 m in a quadtree. A cell of level n+1 is exactly four of level n and holds the same place at coarser detail.
  • A cell ships as pages. A page is one block of bytes for one cell, level and class of data, made by the baker, that mounts without being interpreted item by item.
  • Classes of data, each with its own deadline and budget: collision under and ahead of the player, collision, visual, detail geometry, detail texture, navigation, population, audio, lights.
  • A ring is a time, not a distance. "Collision within 0.5 s", "visual within 2 s". The distance is the time multiplied by the speed, with a floor so that standing still loads something and a cap so that a teleport does not ask for ten kilometres. The region leans along the velocity.
  • Earliest deadline first, within a budget of bytes in flight. A request whose reason has gone is cancelled.
  • The index is resident. Nothing is read from an archive to decide what to read. A page whose hash does not match is refused, counted and reported, never mounted.
  • Deciding runs off the main thread. The main thread takes finished pages and mounts them under a budget in microseconds.
  • Scripts get tickets. A mission asks for a place and waits on a ticket behind a cover sequence. The streamer has no call that blocks.

What would make it a failure even if it works: a frame that waits for the disk; a per-object cost on the main thread creeping back in; radii that need tuning by hand for each vehicle.

Detail by feedback (cluster hierarchies and partly resident textures) is designed and not built. Until it is, a page carries its meshes and textures whole.

Art

Models, trees, materials, the look

Newest first3 entries
In the engine

What the suburb looks like for now

The textured kit and the species trees mounted by the streamer, in the engine. Jacarandas in flower along the streets.
The textured kit and the species trees mounted by the streamer, in the engine. Jacarandas in flower along the streets.

With the kit and the trees mounted through the streamer, the suburb stops being boxes. Red and grey tiled roofs, brick walls, pale verges, fences along the lots, a tree on most frontages. From a few hundred metres up it reads as Perth.

It is a stand-in look, and it helps to say what kind:

  • Everything is opaque and low-polygon, because that is what mounts in one step. The style is a consequence of the streamer, not yet an art direction.
  • Few materials: the kit's buildings, vehicles and props share two atlases and the trees share one palette. Fences, garages and the ground use a few dozen flat colours.
  • Lit by the sun, its shadows and the sky only. Streamed instances do not yet take part in the engine's dynamic global illumination.
  • Placement is from data: a house where there is a real footprint, a road where there is a real road, trees by assumed densities (there is no open canopy data).

What looks wrong is mostly known: houses stretched to fit their footprints, the same few shapes repeating along a street, flat-coloured ground, and no sign of the decade.

No windows at the level of detail placed in cells, no road markings, no retaining walls: houses sit on raw slopes. Lots at corners are wedges. This is today's city, not the 1990s one.

Next: road markings and kerb detail, more house shapes for large plans, and the first pass at what a 1990s street had that today's does not.

First pass

A generated kit of houses, cars and street furniture, on two atlases

A mock street built only from the kit: houses, power poles, a bus shelter, bins, cars of the period.
A mock street built only from the kit: houses, power poles, a bus shelter, bins, cars of the period.

The stand-in boxes are being replaced by a kit: 42 models of ordinary Perth buildings and objects generated with Tripo and Meshy, then cleaned up, simplified and recoloured into 220 kit assets.

  • 17 house shapes, each in up to four colourways: 1960s brick rectangles, fibro cottages, weatherboard, 1970s L-shapes, 1980s brick with a garage, 1990s hip-and-valley roofs, a two-storey, a duplex, a row of units, a verandah bungalow.
  • Other buildings: a deli, a service station with its canopy, a church, a school block.
  • Vehicles: two sedans, a wagon, a ute, a panel van and a bus, in white, silver, blue, red, brown, green and tan.
  • Street furniture and yard things: timber power poles, street lights, a bus shelter, wheelie bins, letterboxes, a Hills hoist, a water tank, garden sheds, a phone box, a post box, traffic lights.

Two materials for the whole kit

Every asset is one surface with UVs on one of two shared atlas textures. That matters because, in this renderer, every material in the scene costs a pass over the whole screen, about 1 ms for each hundred materials. A suburb that looks varied must not get there by having hundreds of materials. Colourways are tiles in the atlas, not new materials.

Houses are 256 to 704 triangles at the level placed in cells, with a finer level (2,000 to 3,000) and a coarser one (about 100) kept beside it.

Fitting houses to real roofs

The world has a real footprint where each house goes. The kit picks, for each footprint's bounding rectangle, one of the three nearest house shapes that fits within a stretch of 1.45 on each axis, and a colourway, both keyed on the building so the choice is stable from build to build. Where nothing fits, the footprint is raised as a plain block.

Part of the house sheet: each shape with its recoloured roofs and walls, and its plan from above.
Part of the house sheet: each shape with its recoloured roofs and walls, and its plan from above.

Honest flaws: houses come out about 15 % smaller in plan than asked and are stretched 1.1 to 1.38 times to fit real footprints; large squarish plans have few shapes; some recoloured walls tint the window frames; which side is the front is a guess for each model, not checked.

First pass

Thirty-one species of tree, all opaque

All 31 species at one scale, at the level of detail used from 50 to 200 m, with a 1.8 m figure beside each. Top row from left: jarrah, marri, tuart, flooded gum, wandoo, peppermint, sheoak, swamp sheoak.
All 31 species at one scale, at the level of detail used from 50 to 200 m, with a 1.8 m figure beside each. Top row from left: jarrah, marri, tuart, flooded gum, wandoo, peppermint, sheoak, swamp sheoak.

Perth's trees are a large part of how it looks from any height, so the tree kit came early: 19 species native to the south-west of Western Australia (jarrah, marri, tuart, wandoo, banksias, paperbarks, sheoaks, grass tree, zamia, the orange-flowering Christmas tree) and 12 that were planted (jacaranda, Norfolk Island pine, London plane, Moreton Bay fig, date palm, Queensland box, lemon-scented gum, olive and others).

Each species starts as a full tree from the Midori tree generator and is reduced to a low-polygon form with clumped crowns.

Why opaque

Trees in games are usually cards with leaves cut out by alpha. Here every tree is solid, for a reason in the engine: a streamed instance must be opaque to mount in one step and be drawn through the visibility buffer. An alpha-tested tree would fall back to the slow path, one object at a time, and trees are the most numerous thing in a suburb after fence panels. So the leaves are geometry, and the style follows from that.

One material for all of them

Every tree is one surface on one shared material. The texture is a palette of ramps, 1024 x 512: one row for each base colour, running dark to light. A vertex's u picks the shade and its v the row, and all three vertices of a triangle stay in one row. That gives darker undersides and variation from clump to clump without a second material. Palm and zamia blades are two opposite-facing triangles 12 mm apart, so they need no double-sided material either.

LevelUsed atTriangles, a tree
0near182 to 650 (median 444)
150 to 200 m76 to 164 (median 118)
2far19 to 41

There are 402 assets: each species in three sizes with up to three seeds, so a wood is not clones. The jacaranda and the Christmas tree come in flower and in leaf. Real dimensions are recorded for each: a 15 m jarrah from the generator is 12 to 15 m across, wider than the stand-in it replaces.

A test street: jacarandas in flower, with a Norfolk Island pine behind.
A test street: jacarandas in flower, with a Norfolk Island pine behind.

A first pass; the conversion is still being tuned. Crowns read as clumps, not foliage, close up. Crowns wider than their height were narrowed in plan to fit (figs by 1.5 times).

Design

The world, its data, the rules

Newest first7 entries
Milestone

The generator, from one suburb to a 21 by 23 km box

The generated area drawn from above by the generator: 21 x 23 km, coast to inner east. Roofs, roads, grass, bush and water as the cells hold them.
The generated area drawn from above by the generator: 21 x 23 km, coast to inner east. Roofs, roads, grass, bush and water as the cells hold them.

The generator that made one square kilometre of suburb now takes any box. The box for the first demo runs from the coast to the inner eastern suburbs and from the northern suburbs down past the port: about 21 by 23 km.

  • 483 tiles, 30,912 cells, generated in parallel. No tile failed.
  • The central five kilometres alone is 7.7 million triangles and 65,000 instance placements.
  • Every kind of place gets the simplest thing that stands up: suburb as the prototype does it (roads with kerbs, lots, houses, fences, trees); the centre as footprints raised to their heights; parks as grass with trees; water as a flat sheet.
  • Each cell is one file in a small documented format, checked by a validator before the baker sees it. The generator and the engine agree only on that format, so either side can change without the other.
  • A rebuild remakes only the tiles whose inputs or code changed.

The pictures here are the generator's own top-down drawings of what it wrote, used to spot mistakes quickly: a rule that paints a residential block as car park shows up at a glance from above.

The five kilometres around the centre. Red is tiled roof, pale grey is commercial roof, dark grey is hardstand.
The five kilometres around the centre. Red is tiled roof, pale grey is commercial roof, dark grey is hardstand.

Known faults: tunnels leave gaps in roads; one block in the first suburb is painted as hardstand; the river bed and sea floor are not written. Only the central five kilometres has been flown and measured in the engine so far.

Draft

Two tiers from one bake, and 60 frames a second

The format a cell takes on disk is written before the pipeline that fills it, and with two tiers from the start: a full tier for desktop and home consoles, and a compact tier for handheld-class hardware. Both are made from the same source by the same bake, as build variants. Neither is made from the other.

Full tierCompact tier
A cell of suburb, measured128 KiB107 KiB as first drafted; 96 with tighter records
A cell of suburb, the limit250 KiB100 KiB
A cell of the centre2.5 MiB or less800 KiB or less
A cell of open country40 KiB or less20 KiB or less
Every cell of the mapabout 32 GiBabout 15 GiB

The compact limit for a cell of suburb started at 60 KiB. The measurement showed 60 can be reached only by building collision, fences and kerbs when a cell mounts, on the slowest CPU of any target, and that has not been timed there. So the limit is now 100, where nothing is built at mount and the saving comes from tighter records alone. The first compact draft saved only 21 KiB, because collision, coarse levels and instances, 81 of 105 KiB, were identical on both tiers.

Rules the format holds to:

  • Mounting a cell costs the bytes read and little else.
  • Ground, its collision and what the game asks about it come from one stored thing, not three that can disagree.
  • A car drives the same on both tiers.

Frame rate

The target is 60 frames a second: no frame longer than 16.7 ms, on the hardware each tier is for. Systems are meant to degrade by construction rather than by retuning. For streaming, the stated bar is stricter than an average: nothing seen before it is loaded, nothing wanted missing, and no single frame over 16.7 ms. The flight over the centre does not meet that last part yet.

This is a draft and not yet approved. Sizes for the centre and for open country are still guesses. Nothing has been measured on the smaller tier's hardware.

Measured

A cell of suburb, generated and counted: 128 KiB

Before fixing the format, about a square kilometre of established suburb and two smaller pieces of other kinds were generated from the open data and counted, cell by cell.

A 128 m cell of established suburb is 128 KiB compressed (median; 154 worst). An inner suburb with lanes is 147. The target was 250.

What an established cell is made of, mean KiB compressed:

PageKiB
Collision45.3
Coarse levels (this cell's share)24.9
Ground source18.9
Ground and road mesh18.4
Instances (527 records)10.9
Navigation (a stand-in)6.7
Points0.6

What the count changed:

  • Collision is the largest page, not the ground and road mesh as the draft had claimed. A baked collision triangle is 43 bytes; the same mesh as quantised vertices is a quarter of that.
  • Fence panels are 56 % of all instances (294 of 527) and 31 % of the collision bytes. Fences along a lot should be one mesh for the cell.
  • Natural ground is 57 % of an established cell's area: yards 36, verges 11, parks and medians 10. Carriageway is 11 to 15 %. So one blended ground material covers most of what is seen from above.
  • The road mesh is 1,300 triangles, 59 % of them kerb.

Scaled to the whole map with a guessed mix of cells, every cell together is about 32 GiB. Open country is now the largest unmeasured term: the one near-pure park cell came to 31 KiB.

Looking at pictures of the result exposed a single-precision fault that had corrupted the coarse levels, and a rule that had turned three residential blocks into hardstand. Both were fixed before the final count.

Not counted yet, and all of it adds: retaining walls and building pads (the suburb measured has a median 6.9 m of relief in a cell, and its houses sit on raw slopes), road markings, the road network for traffic. Ground and vegetation rasters are invented content.

Decision

Crowds: decisions slow and staggered, execution every tick

A city of pedestrians cannot each think every frame, and does not need to.

  • Deciding is slow and staggered; carrying out is every tick. A person perceives and chooses a task at 2 Hz or lower. Steering, animation and the response to being hit run every simulation tick.
  • A rate is a period and a phase, counted in ticks. At 30 ticks a second, a 2 Hz update is every 15th tick, and there are 15 phases. Phases are given out so that each tick carries about the same work: 150 people at 2 Hz are 10 a tick, not 150 on every fifteenth.
  • The stagger is the reaction time. A person ready for something reacts in about a quarter of a second, and in half a second or more when they must choose. A 2 Hz update at a random phase gives each person a delay between 0 and 500 ms, different for each, for nothing. Noticing a shot needs no event that wakes everyone at once.
  • What stays immediate is physical: a body struck by a car, anything two people do together.
  • In a fight, reaction time is a number a designer owns, not a side effect of the rate.
  • The rate falls with distance, with a limit where the player can see: someone watched through a scope cannot take two seconds to react.

The script scheduler has the same rule for its threads, so a designer writes "guards decide four times a second" in one line and each guard lands on a tick of its own.

A design decision with the scheduler behind it built and tested. There are no pedestrians in the game yet.

Data

The open data, and what each source is used for

The world is generated from openly licensed data only. Four sources feed the generator today:

SourceUsed for
Geoscience Australia, 5 m elevation model from LiDARGround height
OpenStreetMapRoad centrelines and classes, one-way streets, lanes, roundabouts, parks, schools, bus stops, paths, water
Main Roads Western Australia open road layersRoad hierarchy, and telling a right of way from a car-park aisle (in the suburb prototype)
Microsoft building footprintsBuilding outlines and heights

Things learned while joining them:

  • OpenStreetMap is not enough for buildings in ordinary suburb. One established suburb has 4 buildings in OpenStreetMap where the Microsoft set has 866. Where OpenStreetMap is complete, its count and area match Microsoft's to within 5 %. So footprints come from Microsoft everywhere.
  • The two road sources are joined by nearest segment. OpenStreetMap gives the geometry; the Main Roads hierarchy overrides the class where more than half the sample points match. 97 to 100 % of road ways found a match.
  • Lots are inferred by subdividing street frontage, guided by the footprints: 983 lots against 852 dwellings in the measured square kilometre. About one in six holds no house, mostly corner fragments, so fences are over-counted by 10 to 15 %.
  • Heights give storeys: a footprint taller than 5.8 m is two storeys; a footprint under 60 m² is an outbuilding.

Licences and the attribution each source asks for are on the credits page.

There is no open tree-canopy data and no open lot boundaries, so tree densities are stated assumptions and lots are inferred. No source has been checked against the ground.

Decision

Terrain: a heightfield in the tools, meshes in the cells

The ground has to hold kerbs, embankments, underpasses, cuttings and river walls in the city, and hills twenty kilometres off in open country. A heightfield drawn at run time cannot hold the first list, and the renderer draws ordinary meshes through meshlets and a visibility buffer, not geometry displaced in a vertex shader.

So the decision is: the heightfield lives in the tools, and what ships is meshes in cells.

  • Source, not shipped. A heightfield for the whole map, a road graph, and outlines of water and built lots.
  • A bake, cell by cell. The heightfield is sampled, roads and lots are cut and flattened into it, kerbs and embankments are generated, and the result is ordinary meshes with materials. Hand-made pieces (tunnels, underpasses) replace generated ground where they are placed.
  • Coarse levels from the same source. Far ground is the same heightfield sampled more coarsely, in cells that are exact unions of four finer ones. That is what the square grid is for. The bake closes the seams between levels.
  • Collision from the bake: a heightfield shape where the cell's ground is a plain surface, a triangle mesh where it is not, with a surface material on each triangle.
  • Open country by the same path: larger cells, coarser ground, the same files.

One answer for city and country means streaming, culling, lighting and collision have no second case.

Still to find out: how many ground layers a pixel may blend, and whether the fade between coarse and fine ground shimmers in motion. It has only been looked at held still.

Premise

The premise: Perth at its real size

The game is an open-world crime game set in a fictionalised Perth, Western Australia, in the 1990s. The map is the whole metropolitan area at its real size, not a compressed impression of it.

That one decision sets most of the others:

  • At the streamer's cell size of 128 m, the metropolitan area is about 397,000 cells, nearly all of them suburb. Nobody places 397,000 cells by hand, so the world is generated from data and then edited.
  • Every 10 KiB in a cell of suburb is about 4 GB on disk, so a cell's size is a design number, not an afterthought.
  • The player can fly. The streamer is sized for a car at 56 m/s (200 km/h) and a light aircraft at 100 m/s.

The real city is the starting guide, not the product. The plan is to start from surveyed open data, wind it back to the 1990s, and move it away from the real place: fictional names, fictional businesses, changed streets. The source data itself is never shipped as it is.

The game runs on Tarragon, a custom fork of the Godot engine with a meshlet and visibility-buffer renderer.

Nothing in the world has been wound back to the 1990s yet. What the screenshots show is the present-day city from open data, with stand-in buildings.

Next: a first list of what has to change between today's map and the 1990s one: roads that did not exist, a rail line that did not, a foreshore that looked different.