No description
  • GDScript 51.3%
  • Python 38.3%
  • GDShader 10.3%
Find a file
Dušan Bratuša a6c164e360 Exploration overhaul: map of Slovenia, discoveries, flight, streaming, Blender props
Walking and flight
- Remove the motorbike and everything that depended on it.
- Walking speed follows Tobler's hiking function and the surface underfoot, with
  momentum, kerb climbing, crouching, wading and stride-driven head motion.
- Free flight with altitude-scaled speed; leaving it eases down to the surface below.

Discoveries
- Named markers with notes, saved per region in absolute coordinates. Saving is
  atomic, keeps a backup and sets damaged files aside. The last position is kept too.
- Shown on the compass, in the world, on both maps and in a journal.

Interface
- A shared design system, and a redesigned HUD, menus, settings and loading screen.
- Full screen setting (F11), and an interface that scales with the window.
- The app opens on an interactive map of Slovenia using GURS WMTS layers: place,
  address and coordinate search, boundary preview, sizes up to 20 km, an estimate of
  the build, and generation with progress and cancel. Saved regions stay on the map.

Large regions
- Vegetation, buildings, roads and props stream around the camera on worker threads;
  far buildings are plain massing with true footprints, heights and roof colours.
- Pipeline work now follows each building and vineyard rather than the whole grid.
  LiDAR sheets run in parallel and their source files are removed once processed.
- Regions above 8 km use a 2 m grid. Tested up to 12 km.

Visuals
- Photographed sky panoramas, turned to the real sun and scaled to one irradiance.
- Roads as draped geometry, far terrain coloured by the orthophoto, lakes as deep water.
- Sentinel-2 imagery for the backdrop across the border.
- 49 props modelled in Blender, placed from OSM or by rule (documented in the README).

Checks
- In-engine suite extended to 44 checks: movement, discoveries, interface flows,
  streaming, prop placement, leaving and returning to a region.
- Validation limits adjusted for real cliffs and for coarser terrain grids.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 11:33:51 +01:00
configs Slovenia Explorer: real-world Slovenian regions in Godot 2026-10-30 00:33:28 +01:00
docs Exploration overhaul: map of Slovenia, discoveries, flight, streaming, Blender props 2026-10-30 11:33:51 +01:00
godot Exploration overhaul: map of Slovenia, discoveries, flight, streaming, Blender props 2026-10-30 11:33:51 +01:00
pipeline Exploration overhaul: map of Slovenia, discoveries, flight, streaming, Blender props 2026-10-30 11:33:51 +01:00
.gitignore Exploration overhaul: map of Slovenia, discoveries, flight, streaming, Blender props 2026-10-30 11:33:51 +01:00
check.sh Slovenia Explorer: real-world Slovenian regions in Godot 2026-10-30 00:33:28 +01:00
README.md Exploration overhaul: map of Slovenia, discoveries, flight, streaming, Blender props 2026-10-30 11:33:51 +01:00

Slovenia Explorer

A geographical exploration simulator that rebuilds real places in Slovenia at 1:1 scale from open national geodata. Pick any spot on an interactive map of the country, choose how large an area you want (up to 20 × 20 km), and walk it or fly over it. Every hill, terrace and valley comes from the national LiDAR survey, buildings and roads from OpenStreetMap, ground colour from the GURS orthophoto, every tree from the LiDAR canopy. Mark what you find; your discoveries stay with the region.

Bled from the water

The map of Slovenia Choosing a new region
Exploring on foot with discoveries on the compass and the map Map and journal of discoveries
Bled from the air A 12 × 12 km region of Gorenjska
A hayrack beside a village road Vineyard rows at Svetinje

Ordinary screenshots. The bar the rendering is held to is in docs/VISUAL_TARGET.md; what changed, what it costs and what still separates it from a commercial open-world game is in docs/QUALITY_REPORT.md.

What is real and what is procedural

Element Source Notes
Terrain elevation ARSO/GURS national LiDAR 2014–2015, DMR1 (1 m bare-earth model) Copied sample-for-sample; validated against the raw tiles (max error 0.0 mm).
Distant backdrop (8 km around) Copernicus GLO-30 DEM + GURS orthophoto at 7 m Visual only, not walkable. Within 600 m of the seam it is shifted onto the LiDAR terrain; the largest shift is recorded in region.json.
Tree positions, heights, crown size LiDAR GKOT classified point cloud (classes 3–5) Tree tops = local maxima of the canopy height model. Crown radius = measured crown area, capped at 0.6 × the distance to the nearest tree.
Vineyard rows GURS orthophoto stripes + LiDAR canopy, inside OSM vineyards Direction, spacing and phase fitted per 30 m patch to the photo's row stripes (89 % of patches); vines planted only where the LiDAR saw vine canopy. Trellis posts every ~5 m are approximate (drawn 0.62 m along the row from the vine trunk they were placed on). Beyond 26 m, a gap of exactly one missing plant in a row is drawn as leaf wall (no trunk), so distant rows do not read as dashed lines; up close the gap is shown as measured.
Building footprints OpenStreetMap Aligned with LiDAR roofs: 91 % overlap at zero shift (checked automatically).
Building heights, roof form, towers LiDAR roof returns (class 6) inside each footprint Gable vs. hip chosen by fitting both to the LiDAR roof; towers split out where part of the roof stands ≥ 4 m higher. Fallback: OSM height / building:levels, then a documented default.
Roof colour GURS orthophoto, median over the footprint Hue kept; brightness mapped to a plausible tile albedo.
Entrance side Wall facing the nearest OSM road The door itself is procedural.
Power lines, poles, pylons OpenStreetMap (power=line/minor_line, pole, tower) Positions from data; pole heights, crossarms and wire sag are typical values.
Wayside shrines OpenStreetMap (historic=wayside_shrine) Position from data; shape is a typical small chapel.
Roads, paths, streams, ponds, land use OpenStreetMap Roads are painted into the terrain at 25 cm sub-sample accuracy. Verges beside paved roads are procedural.
Ground colour GURS orthophoto DOF025 Calibrated per surface type to plausible albedos, keeping the photo's real variation.
Land cover where OSM has none LiDAR canopy (tall canopy → forest, else grassland) Flagged per cell in landcover_source.png.
Windows, doors, shutters, plinths, gutters, downpipes, chimneys, tile courses, wall colours and weathering Procedural, fitted between the measured ground and roof line Visual detail only: no storeys, walls or openings are taken from data.
Tree, shrub and vine models Procedural skeletons grown to each LiDAR tree's height and crown radius, with photographic CC0 leaf and bark textures (ambientCG), rendered to twig cards and impostors in Blender Species (oak, hornbeam, chestnut, black locust) are chosen per tree for variety, not from data.
Grass and ground cover Procedural and CC0 (see godot/assets/groundcover/) Density from the LiDAR/OSM ground-cover layer; plants are visual detail.
Ground, building and bark textures CC0 photoscans (Poly Haven, ambientCG) Sources recorded next to each asset set.
Border of Slovenia on the map OpenStreetMap (ODbL), simplified to 60 m, in godot/assets/ui/ Used to draw the country and to refuse areas without LiDAR.
Sky Photographed panoramas (Poly Haven, CC0), chosen by sun elevation and turned towards the real sun The clouds are real but not those of any given day.
Fences, walls, benches, bins, street lamps, bus stops, bollards, gates, rocks OpenStreetMap, where mapped Position from data; the models are from the Blender prop kit.
Garden fences along streets, firewood, bee houses, hayracks (kozolec), vineyard rattles (klopotec), road delineators, balconies, flower boxes, boulders, stumps, fallen logs Blender prop kit, placed by rule from land cover, roads and buildings Typical for the landscape, not data: they are decoration and stay on the same spot every visit.
Road surfaces Course and width from OpenStreetMap, heights from the terrain Wear, lane markings and the grass strip of farm tracks are typical appearance.
Distant backdrop Copernicus GLO-30 heights, GURS orthophoto; Sentinel-2 cloudless (EOX, CC BY 4.0) across the border Visual only: not walkable.
Sun position Computed for the region's latitude/longitude and time

Nothing outside the measured data is invented: a region with missing elevation fails to import (DataGapError) instead of being filled with made-up terrain. The only filling allowed is isolated empty samples (at most 0.05 % of the region), and their count is written to region.json.

Requirements (macOS, Apple Silicon)

  • Godot 4.7 (tested with 4.7.1) at /Applications/Godot.app
  • uv for the Python pipeline (Python 3.12–3.13 is installed automatically)
  • PDAL and GDAL: brew install pdal gdal
  • Terrain3D 1.0.2 is bundled in godot/addons/terrain_3d (MIT licence)
  • Blender 5.1 at /Applications/Blender.app (or BLENDER=/path/to/blender) to build the plant and prop assets (sge assets; done once)
  • Disk: about 5 MB per km² of permanent cache and 16 MB per km² per region (the app shows the estimate before building); during a build each national LiDAR sheet takes about 105 MB until it is processed

Quick start

cd pipeline
uv run sge assets                                   # textures, plants, skies, props (cached; once)
uv run sge import --config ../configs/svetinje.toml # optional example region

Then open godot/project.godot in Godot and press Play (F5), or:

/Applications/Godot.app/Contents/MacOS/Godot --path godot

Add -- --region=svetinje to skip the map.

Choosing a place

The app opens on the map of Slovenia (official GURS atlas, aerial and LiDAR relief layers, cached in the user data folder after the first view).

  1. Find the place. Drag to pan, scroll or pinch to zoom, or search for a place or address in the panel (OpenStreetMap Nominatim; results stay inside Slovenia). Coordinates work too: 46.3683, 14.1146 in degrees or 430000 136000 in EPSG:3794 metres. Search and naming a clicked spot send what you typed or that position to OpenStreetMap; nothing else leaves the computer.
  2. Set the area. Click to centre it; drag the box to move it, drag a corner or use the slider to resize it, from 1 × 1 km to 20 × 20 km. The 1 km grid shown is the national LiDAR sheet grid.
  3. Name it and generate. The panel shows the download, build time and disk space before you start. An area reaching outside Slovenia cannot be generated (there is no LiDAR there), and the map says so. A build shows its progress, can be cancelled and keeps what it has downloaded.

Saved regions appear on the map and in the panel with their discoveries, ready to continue.

Controls

Key Action
W A S D / arrows, mouse walk and look
Shift jog
Space jump
C or Ctrl crouch
F take off / land; leaving flight eases down to whatever is below
In the air: W A S D, Space or E, Q or C fly where you look, up, down
In the air: Shift, wheel, + / − faster; flight speed
G mark the spot you are looking at
E open the discovery beside you
M or Tab map and discoveries
N minimap
F3 exact position: WGS84, D96/TM, elevations, sun, FPS
[ / ] time of day
U hide the interface
F12 save a picture to Pictures / Slovenia Explorer
F2 graphics quality
F11 full screen (also in Settings)
H / F1 controls and data credits
Esc menu: settings, regions, quit

Walking speed follows Tobler's hiking function of the real slope and the surface underfoot (asphalt, gravel, grass, forest floor), with momentum, kerbs walked over without jumping, a head that moves with the stride and water slowing you down. Head motion can be turned down in Settings. Flight speed grows with the height above the ground, so low passes stay controllable and high ones cross the map.

Discoveries

Press G to mark what the crosshair points at, or click the map (M) and choose Add a discovery here. Give it a name, a kind and notes. Discoveries show on the compass, in the world, on both maps and in the journal beside the full map, where you can filter, edit and travel to them.

They are saved under the user data folder (~/Library/Application Support/Godot/app_userdata/Slovenia Explorer/discoveries/<region>.json) in absolute coordinates, so they survive rebuilding the region. Saving writes a new file and keeps the previous one as .bak; a damaged file is set aside as .corrupt rather than overwritten. Your last position is kept the same way.

Importing from the command line

The map in the app does all of this. For scripts and batch builds, every import needs a name (lowercase letters, digits, -, _) and a location. The region is always square; --size is its side in metres (even multiple of the spacing), --spacing the terrain sample spacing (default 1 m).

cd pipeline

# Centre in WGS84 degrees (latitude, longitude), 2 km square
uv run sge import bled --center 46.3683,14.1146 --size 2000

# Centre in D96/TM (EPSG:3794) metres, 3 km square at 2 m spacing
uv run sge import ptuj --center-en 566850,142600 --size 3000 --spacing 2

# Bounding box in EPSG:3794 (minE,minN,maxE,maxN) or in degrees (west,south,east,north)
uv run sge import piran --bbox 387200,43200,389200,45200
uv run sge import piran2 --bbox-wgs84 13.555,45.520,13.582,45.537

# See the grid and the national LiDAR sheets a region needs, without downloading
uv run sge import bled --center 46.3683,14.1146 --dry-run

# Reusable configuration file (see configs/svetinje.toml)
uv run sge import --config ../configs/myregion.toml

You can also import from inside the game: the start menu has an Import a new Slovenian region form that runs the same command and streams its log.

Useful options: --spawn-place "Name" (spawn near an OSM place), --title, --refresh-osm (re-download OpenStreetMap), --offline (cache and local files only), --force (rebuild), --no-engine-export (neutral package only). List built regions with uv run sge list; re-check one with uv run sge validate NAME.

Automatic downloads

Data Endpoint Licence / attribution
DMR1 1 m terrain, GKOT point cloud http://gis.arso.gov.si/lidar/{dmr1,gkot/laz}/b_<block>/D96TM/… (block discovered automatically, cached in data/raw/arso_lss/blocks.json) ARSO / GURS open data
Orthophoto GURS WMTS SI.GURS.ZPDZ:DOF025, level 13 (0.7 m); level 10 (7 m) for the backdrop GURS open data — "Vir: Geodetska uprava RS"
Distant backdrop elevation Copernicus GLO-30 DEM (public AWS bucket, cloud-optimised GeoTIFF windows) © DLR e.V. 2010-2014 and © Airbus Defence and Space GmbH 2014-2018, provided under COPERNICUS by the EU and ESA
Roads, buildings, land use, water Overpass API © OpenStreetMap contributors, ODbL
Ground/roof/bark textures ambientCG CC0

Local files (newer CLSS 2023–2025 LiDAR, other datasets)

The newer CLSS survey (10 points/m², clss.si) has no public download API: sheets are downloaded by hand in the clss.si viewer (enable the "CLSS 2023 - 2025 (kilometrska mreža)" layer, click a 1 km sheet, max. 20 downloads per day). Download for each sheet covering your region:

  • GKOT (classified point cloud, .laz) — gives terrain, trees and roofs, or
  • DMR (terrain, .laz) plus GKOT for vegetation, and optionally
  • POF (RGB orthophoto, .tif)

then pass them to the importer:

uv run sge import mojkraj --center 46.05,14.50 --size 2000 \
    --laz ~/Downloads/clss/GKOT_*.laz --ortho ~/Downloads/clss/POF_*.tif \
    --vertical-datum "SVS2010 (EPSG:8690)"

Any GeoTIFF DEM (--dem file.tif) or E;N;H text grid (--dem file.asc) works too. Local data has priority; national tiles fill whatever local files do not cover (use --offline to forbid downloads). The coordinate system is read from each file; files without one are rejected unless you state it with --src-crs EPSG:3794 (D96/TM and the old D48/GK grid overlap numerically, so it is never guessed). Inputs in other projections are reprojected to EPSG:3794.

Vertical datum

Heights of the 2014–2015 national survey are normal heights in the SVS2000 (Trieste) system — the survey predates Slovenia's 2019 switch to SVS2010 (Koper, EPSG:8690). The two differ by a smoothly varying offset of a few decimetres, which does not affect relief. The datum is recorded in region.json (crs.vertical) and shown in the HUD; mixed sources are reported as "mixed".

Project layout

configs/             region configurations (TOML)
pipeline/            engine-independent Python GIS pipeline (`sge` CLI)
  slovenia_gis/
    region.py        square region + shared node-registered sampling grid
    crs.py           EPSG:3794 target, CRS detection/validation, vertical datums
    download.py      cached, atomic HTTP downloads
    sources/         arso_lidar.py (DMR1/GKOT), osm.py (Overpass), ortho.py (GURS WMTS)
    lidar.py         PDAL pipelines: ground / vegetation / roof rasters from LAZ
    rasters.py       mosaicking and resampling onto the region grid
    landcover.py     land cover, road-surface coverage, ground-cover density
    infrastructure.py roads, buildings (LiDAR heights, roof form/colour), water
    vegetation.py    trees (measured crowns), bushes, vineyard rows fitted to the orthophoto
    context.py       distant backdrop from Copernicus GLO-30 and the low-resolution orthophoto
    package.py       builds the region package and region.json
    validate.py      package validation (also compares with raw source tiles)
    terrain3d.py     the only engine-specific part: Terrain3D control/colour maps, ground textures
    assets.py        `sge assets`: builds every runtime asset of the Godot client
    assets_buildings.py, assets_groundcover.py, assets_vegetation.py   CC0 materials and plant models
    assets_sky.py    photographed sky panoramas: sun removal, irradiance and horizon measurement
    assets_props.py  the prop kit, modelled in Blender
  blender/           Blender scripts: tree/vine generator, twig-card and impostor baking, plant reduction, prop kit
  tests/             unit tests (pytest)
godot/               Godot 4.7 project
  scripts/main.gd    the application: map → loading a region → exploring; --benchmark mode
  scripts/settings.gd   preferences
  scripts/region_package.gd, geo.gd (EPSG:3794 ↔ WGS84, Krüger series)
  scripts/world/     terrain, distant backdrop + haze ring, cell streaming, buildings (facades, roofs,
                     materials, massing), roads, props, power lines, water, vegetation, grass and ground
                     cover, sky/sun/haze, ambient audio
  scripts/graphics_quality.gd   low/medium/high/ultra presets
  scripts/player/    the explorer: walking and free flight
  scripts/discoveries/  markers: persistent store, stakes in the world, editor
  scripts/ui/        design system (ui_theme, ui_icons), map of Slovenia, home screen, region plan and
                     pipeline job, HUD, full map and journal, menus
  shaders/           sky (photographed panoramas), terrain (Terrain3D override), roads, vegetation, grass
                     and ground cover, buildings (walls, roofs, glass, detail), water, interface
  tests/run_tests.gd in-engine validation
data/raw/            download cache (not in version control)
regions/<name>/      generated region packages (not in version control)
check.sh             runs every automated check

Region package (engine-neutral)

All rasters share one node-registered grid in EPSG:3794: sample (row, col) lies at E = E0 − size/2 + col·s, N = N0 + size/2 − row·s (row 0 is north, both edges are sampled, so 2 km at 1 m is 2001 × 2001). Vector data uses a local metric frame: x = E − E0 (east), y = N − N0 (north), z = absolute elevation. Godot maps it to X = x, Y = z, Z = −y.

File Content
region.json grid, origin, CRS and vertical datum, sources and attribution, file index, spawn, control points (local ↔ D96/TM ↔ WGS84 ↔ height)
terrain/height.tif, height.r32 float32 DTM (GeoTIFF; raw little-endian, row 0 = north)
terrain/height16.png 16-bit heightmap with height16_offset/scale — e.g. for an Unreal Landscape
terrain/landcover.png, landcover_source.png class per sample (see region.json), and its origin (OSM / LiDAR)
terrain/roads.png RGB coverage of asphalt / gravel / dirt per sample (0–255)
terrain/ground_cover.png, canopy.tif, ortho.jpg grass density, canopy height (m), orthophoto on the grid
features.json roads (with width/surface/bridge, points on the terrain), buildings (footprint, ground min/max, eave/ridge z, roof form gabled/hipped/flat, ridge direction, tower parts, road-facing wall, colours, height source), waterways, water areas, places, power lines (points, supports), landmarks (shrines, standalone poles)
vegetation/instances.bin float32 records x, y, z, height, radius, yaw_deg, kind (broadleaf, conifer, bush, vine, trellis post; for posts radius is the wire length to the next post)
context/height.r32, context/ortho.jpg distant backdrop: 16 × 16 km at 25 m (Copernicus GLO-30, feathered onto the LiDAR terrain at the seam) and its orthophoto
map.png cartographic overview used by the in-game map
engine/terrain3d/ Terrain3D control map (control.r32) and colour map (color.png)

To use a region in Unreal Engine, import height16.png as a Landscape (scale Z by height16_scale × 100 cm per unit, X/Y by the sample spacing), and read features.json / instances.bin for foliage and buildings; nothing in the package depends on Godot except engine/terrain3d/.

Validation

./check.sh            # or ./check.sh <region>

runs:

  1. Pipeline unit tests (pipeline/tests): grid geometry, CRS rules (no guessing), DMR1 text conversion, seam-free mosaicking, gap rejection, Terrain3D control-map bit layout, and full validation of the Svetinje package when it exists.
  2. Package validation (sge validate): GeoTIFF CRS/transform, raw vs GeoTIFF identity, plausible elevations and slopes, real relief, 16-bit round trip, control points through pyproj, an independent re-read of every raw DMR1 tile compared with the packaged terrain (1:1 scale, no shift), roads/vegetation/spawn on the terrain, building integrity, OSM-vs-LiDAR building alignment (best overlap must be at zero shift), Terrain3D map integrity.
  3. Godot script compilation.
  4. In-engine validation (godot/tests/run_tests.gd, headless): the GDScript projection against pyproj (0.05 mm), Terrain3D heights equal the package at 5000 random samples, vertical relief reproduced exactly, roads/buildings/vegetation on the terrain, roof collision at LiDAR heights; walking at human speeds and the hiking-function slope law; taking off, flying and landing without a jump in the camera; discoveries surviving a restart, with recovery from a damaged file; the discovery, map, travel and menu flows; streaming and reaching the far corner of a region; and the region picker accepting a place in Slovenia and refusing one outside it.

Rendering

  • Sky, sun and haze agree (shaders/sky.gdshader, world_lighting.gd): the sky is photographed. Panoramas are chosen by the sun's elevation and cross-fade with the time of day, are turned so their bright side faces the real sun (computed for the region and time), and are scaled to one physical sky irradiance; the sun in the photograph is painted out and drawn where it really is. Distant land fades to the horizon colour of the sky in that direction, over a 70 km ring around the backdrop.
  • Terrain (shaders/terrain.gdshader, a Terrain3D shader override): the orthophoto colour map is read coarse near the eye and at full resolution from ~20 m, materials are 2K photoscans blended by their height maps and de-tiled, embankments are triplanar. Far away the orthophoto alone sets the colour; forests take canopy colour, since orthophotos are flown in all seasons. (The shader also fixed the old "black sliver" NaN pixels.)
  • Roads are geometry draped on the terrain around the camera, with crisp worn edges.
  • AgX tone mapping with physically scaled light; temporal anti-aliasing (MetalFX on macOS, FSR 2 elsewhere) so foliage and grass blades do not shimmer.

Graphics quality and performance

Preset AA Shadows SSAO / SSIL Grass radius Vegetation draw distance
low FXAA, 75 % resolution (FSR 1) 2048, 200 m, 2 splits off / off 18 m 60 %
medium temporal, 77 % resolution 4096, 300 m on / off 26 m 80 %
high (default) temporal, native 8192, 450 m on / off 34 m 100 %
ultra temporal, native 8192, 650 m on / on 44 m 140 %

Everything used is supported by Godot's Forward+ renderer on Metal. Choose a preset with F2 or --quality=low|medium|high|ultra. --render-scale=<f> overrides the 3D resolution, for example 1.5 or 2.0 for a GPU stress test. --time=HH:MM sets the local time of day.

--benchmark visits fixed viewpoints and prints frame times (add --shots=DIR for screenshots, --views=a,b to pick viewpoints, --no-hud to hide the HUD, --view-at=x,y,z,bearing,pitch[,fly] for an extra viewpoint):

/Applications/Godot.app/Contents/MacOS/Godot --path godot -- --region=svetinje --benchmark --shots=/tmp/shots

Measured on an Apple M5 Max with 48 GB (Metal, 1920 × 1080, high, display at 60 Hz, so 60 FPS is the cap):

Region Size Buildings Trees and plants Load Memory FPS at 1920 × 1080
Svetinje 2 × 2 km, 1 m 303 197 k 8 s 60 (cap), p99 ≤ 17.9 ms
Bled 6 × 6 km, 1 m 5 683 197 k 13 s 4.5 GB 60 (cap), p99 ≤ 17.7 ms even at --render-scale=1.5
Gorenjska 12 × 12 km, 2 m 15 132 627 k 18 s 5.2 GB 60 (cap), p99 ≤ 17.4 ms
  • Headroom: Godot reports no GPU time on Metal, so it was measured by supersampling. Bled holds the 60 Hz cap at 1.5× (2.25 times the pixels) and runs at 38–51 FPS at 2× (4 times the pixels).
  • Large and Retina screens: the scene renders at up to 4.6 megapixels on high, upscaled by MetalFX, and the interface scales with the window.
  • Building a region: Bled took about 6 minutes the first time (49 LiDAR sheets) and 46 s from the cache; a 12 km region about 30 minutes, part of it competing with other work on the same machine. The full-size point clouds are deleted once rasterised, so the permanent cache is about 5 MB per km².

Known limitations

  • The automatic terrain source is the 2014–2015 survey; the newer CLSS data must be downloaded by hand (see above). OSM is current, so buildings newer than 2014 get default heights (height_source: default).
  • The distant backdrop is a 30 m surface model (it includes forest canopy) with a 7 m orthophoto. Across the national border it uses Sentinel-2 cloudless imagery, or the median colour if that service cannot be reached.
  • Tree species are not in the data: OSM leaf_type is used where mapped, otherwise broadleaf; the broadleaf species (oak, hornbeam, chestnut, black locust) are chosen for variety. Roofs are gabled, hipped or flat (plus tower roofs). Windows, shutters, doors, chimneys, gutters and trellis posts are procedural.
  • Audio (wind, leaves, footsteps) is synthesised. See docs/QUALITY_REPORT.md for the full list of remaining gaps against a commercial open-world game.
  • Bridges get a simple deck; tunnels and culverts are skipped.
  • Larger regions take memory and disk in proportion to their area. Terrain and its maps are held whole in memory; regions above 8 km use a 2 m terrain grid. Everything standing on the ground streams around the camera: trees beyond 3 km are not drawn (the orthophoto shows the forest there), and buildings beyond 800 m are plain massing with true footprints, heights and roof colours.
  • There is no bathymetry in the data, so lakes read as deep water from shore to shore and are waded.