mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-10-17 08:39:19 +02:00
b877bc0772
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.
88 lines
2.9 KiB
C++
88 lines
2.9 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
module;
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <map>
|
|
#include <vector>
|
|
#include "scene/quantizedmeshreader.h"
|
|
|
|
export module eu07.rendering.terrainmesharena;
|
|
|
|
export {
|
|
|
|
// One vertex buffer and one index buffer for the whole terrain.
|
|
//
|
|
// Tiles are put in and taken out as the camera moves, so each buffer is handed out in pieces and
|
|
// the pieces are given back. What this buys is the drawing: every resident tile lives in the same
|
|
// two buffers behind the same vertex array, so a frame is one glMultiDrawElements rather than a
|
|
// bind and a draw per tile. Vertices are measured from one point for the whole terrain, which is
|
|
// what makes that possible.
|
|
//
|
|
// The buffers grow when a tile will not fit and nothing can be freed; they never shrink.
|
|
class terrain_mesh_arena {
|
|
|
|
public:
|
|
// where a tile sits in the two buffers
|
|
struct piece {
|
|
std::uint32_t firstvertex { 0 };
|
|
std::uint32_t vertices { 0 };
|
|
std::uint32_t firstindex { 0 };
|
|
std::uint32_t indices { 0 };
|
|
bool held() const { return indices != 0; }
|
|
};
|
|
|
|
terrain_mesh_arena() = default;
|
|
~terrain_mesh_arena();
|
|
terrain_mesh_arena( terrain_mesh_arena const & ) = delete;
|
|
terrain_mesh_arena &operator=( terrain_mesh_arena const & ) = delete;
|
|
|
|
bool create();
|
|
void destroy();
|
|
|
|
// puts a tile's mesh in. returns a piece that is not held when it did not fit
|
|
piece put( quantizedmesh::reader::tile_data const &Tile );
|
|
void take( piece &Piece );
|
|
|
|
// bound for drawing; the index buffer goes with it
|
|
std::uint32_t vertexarray() const { return m_vao; }
|
|
|
|
std::size_t vertexbytes() const { return m_vertexroom * sizeof( quantizedmesh::render_vertex ); }
|
|
std::size_t indexbytes() const { return m_indexroom * sizeof( std::uint32_t ); }
|
|
std::size_t bytes() const { return vertexbytes() + indexbytes(); }
|
|
std::size_t verticesheld() const { return m_verticesheld; }
|
|
|
|
private:
|
|
// a run of free slots in one of the buffers, kept in order so that neighbours can be joined
|
|
class span_list {
|
|
public:
|
|
void clear() { m_free.clear(); }
|
|
void give( std::uint32_t At, std::uint32_t Count );
|
|
// the first run large enough, or the count when there is none
|
|
bool take( std::uint32_t Count, std::uint32_t &At );
|
|
private:
|
|
std::map<std::uint32_t, std::uint32_t> m_free; // where to how many
|
|
};
|
|
|
|
bool grow_vertices( std::uint32_t Wanted );
|
|
bool grow_indices( std::uint32_t Wanted );
|
|
|
|
std::uint32_t m_vao { 0 };
|
|
std::uint32_t m_vertexbuffer { 0 };
|
|
std::uint32_t m_indexbuffer { 0 };
|
|
std::uint32_t m_vertexroom { 0 };
|
|
std::uint32_t m_indexroom { 0 };
|
|
span_list m_freevertices;
|
|
span_list m_freeindices;
|
|
std::size_t m_verticesheld { 0 };
|
|
};
|
|
|
|
} // export
|