Cook the ground into a quadtree of mesh tiles, and keep the mesh the scenery drew

The ground in a scenery is already an irregular mesh, so the cook keeps it: it cuts the
triangles along the tile grid, welds what coincides, and builds each coarser level by
collapsing edges. Nothing is resampled, nothing is interpolated, and a hole the scenery left
stays a hole. What was here before threw the triangles away, kept their vertices and built a
fresh Delaunay triangulation over them, which filled every hole, merged the two heights of
every retaining wall into one, and - because it never erased the super-triangle - emitted
indices three too large together with triangles reaching out to the artificial corners.

Tiles form a quadtree, as Cesium Quantized Mesh intends. A distant tile is a large one, so the
horizon costs tens of tiles rather than the thousands a fixed grid needed, and the level to
draw follows from the tile's own geometric error against what the screen can resolve - which is
what the format carries that field for. Every vertex on a tile's border survives into all of
its coarser levels, and so does every edge between two of them, so two neighbours drawn at
different levels share their border exactly: there is nothing to stitch and nothing to morph.

The file layout is the format's, with two deliberate departures, both written down in
quantizedmeshformat.h: the geodetic header fields carry scenery metres, there being no
geographic reference to convert from, and the material a vertex belongs to rides in an
extension of ours. Texture coordinates are not stored at all - ground tiles in world space, so
the coordinate follows from the position and from how many metres one repeat of the material
covers, measured off the scenery once and kept in the terrain's table.

Tiles live in one archive beside the scenery, an entry each, compressed on its own. Baltyk
cooks to 546 kB against 2.2 MB of heightfields, quark to 361 kB against 9.6 MB, tomaszewo to
375 kB against 9.9 MB.

Drawing is one call a frame: every resident tile lives in the same vertex and index buffer,
with its vertices measured from the middle of the terrain so that the whole map fits in floats,
and a frame is one glMultiDrawElementsBaseVertex over the tiles the walk chose and the frustum
kept. On baltyk that settles at 291 tiles resident, 16 MB of mesh, 85 tiles and 6k triangles
drawn.

What counts as ground is what the scenery says, not what its triangles look like. A node under
origin, rotate or scale is an object standing on the ground; a material with an alpha channel is
a tree, a bush, a fence or a catenary mast. Everything else is laid whichever way it faces, so
the side of an embankment or a cutting goes in with the rest instead of leaving a hole along
every bank. Whatever is left out is recorded per node, and the scenery goes on drawing it.

A cook is a cache: it is used again only when the archive, the note of which nodes went into it
and the manifest of what the scenery was made from all agree. A manifest listing a file the
scenery names but does not have used to fail that test for ever, since an absent file never
matches - quark has such an include, and nothing beside it could ever be reused.

tools/terraincook cooks the same way outside the engine, and meshtest beside it checks what the
cook promises: a tile reads back as written, neighbouring tiles agree on their border to the
millimetre, a hole is not filled in, a wall is laid exactly once, and a material's tiling comes
out of the source. seamcheck.py goes: it tested the morphing constants of a heightfield nothing
reads any more.

simulation/terrainbake.cppm

@@ -20,66 +20,54 @@ import eu07.model.vertex;
 
 export {
 
-// Baking a scenery's heightfield on its first run, and deciding on every later run which
-// triangles it replaces.
+// Cooking a scenery's terrain into mesh tiles on its first run, and leaving out the triangles
+// the tiles stand for on every run after that.
 //
-// A cooked heightfield is what makes a large scenery affordable - l204 loads in 25 seconds
-// against 219, in 1.9 GB against 9.1 - but until now it had to be produced by hand with the
-// terraincook tool and named in the scenery text. This bakes it the first time the scenery is
-// opened and picks it up by itself afterwards.
-//
-// Nothing here guesses what terrain is. Every triangle the scenery draws is laid into the
-// heightfield where it is drawn, and afterwards each one is asked whether the heightfield still
-// shows it. A tree, a wall or a gantry stands on its edge and never reaches a sample; a bridge
-// deck loses its samples to the ground beneath; those are drawn as they always were. Only
-// triangles the heightfield really shows stop being drawn on their own, so nothing can vanish
-// from the scenery - the worst a bad bake can do is draw something twice.
-//
-// A bake is used only while every file the scenery included when it was made still has the
-// content it had (cookdeps): the scenario file itself is not among them, since the launcher
-// rewrites it on every start and the terrain lives in what it includes. Within a bake that
-// holds, a triangle node is recognised by the file and line it is written at, the parameters
-// its include was given, and the origin and rotation in force.
-//
-// The rasterising is scene/terraincooker.h, the same code the tool uses.
+// The first load lays every triangle of ground into the cook and writes the tiles beside the
+// scenery, along with a note of which nodes went into them and of what the scenery looked like
+// at the time. Later loads read that note: a node the tiles stand for is not built at all, one
+// the tiles stand for in part is built without those triangles, and if anything the scenery is
+// made of has changed since, the lot is cooked again.
 namespace simulation::terrainbake {
 
-// what to do with one triangle node
 enum class verdict {
-    draw,   // the heightfield does not show it: import and draw it as written
-    skip,   // the heightfield shows all of it: do not even import it
-    filter  // the heightfield shows some of it: import it and draw only the rest
+    draw,     // the tiles do not stand for this node: build it as written
+    skip,     // the tiles stand for all of it
+    filter    // the tiles stand for part of it; build the rest
 };
 
 struct node_plan {
     verdict what { verdict::draw };
-    // for filter: one entry per triangle in import order, true where it is still drawn
+    // per triangle of the node, whether the scenery still draws it. only for verdict::filter
     std::vector<bool> drawn;
 };
 
-
-// called before the scenery is parsed. picks up a heightfield baked earlier together with its
-// node table, or arms the bake when there is none
-void begin( std::string const &Sceneryfile );
-// what the load is to do with one triangle node, decided in one place: whether it is read at
-// all, whether it goes into a bake, and which of its triangles are still drawn
 struct node_decision {
-    bool skip { false };      // step over it without importing
-    bool bake { false };      // hand it to add() once imported
+    bool skip { false };
+    bool bake { false };
     std::uint64_t key { 0 };
     node_plan plan;
 };
 
-// Worldspace says whether the node stands in world coordinates, which is all that decides it
-// when the scenery names a hand-cooked heightfield of its own
+// picks up tiles cooked earlier, or arms the cook when there are none
+void begin( std::string const &Sceneryfile );
+// whether triangles are being collected for a cook
+bool collecting();
+
+// what to do with one triangle node of the scenery
 node_decision examine(
     std::string const &File, std::size_t const Line, std::vector<std::string> const &Parameters,
     std::string_view const Type, glm::dvec3 const &Offset, glm::vec3 const &Rotation, bool const Worldspace );
-// one triangle node, in world space, as it is about to be drawn
-void add( std::uint64_t const Key, std::vector<world_vertex> const &Vertices, std::string_view const Material );
-// called once the scenery has been parsed, with every file it included. writes the
-// heightfields, their node table and the manifest of what they were made from; or, when a
-// bake was used, checks the scenery still includes what that bake was made from
+
+// hands a node's triangles to the cook, where they are placed in the world. a material with an
+// alpha channel is not ground - it is a tree, a bush, a fence or a catenary mast - and is left to
+// the scenery to draw
+void add(
+    std::uint64_t const Key, std::vector<world_vertex> const &Vertices, std::string_view const Material,
+    bool const Translucent );
+
+// writes the tiles, or reports on what the tiles cooked earlier stood for. Included is every
+// file the scenery read, which is what tells a later load whether it is still the same scenery
 void finish( std::string const &Sceneryfile, std::vector<std::string> const &Included );
 
 } // namespace simulation::terrainbake