World Streaming Part 1

editor/editorTerrainStreamer.cpp

@@ -0,0 +1,289 @@
+/*
+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/.
+*/
+
+#include "stdafx.h"
+#include "editor/editorTerrainStreamer.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <filesystem>
+#include <fstream>
+#include <string>
+
+// simulation-level streamer instance (see header)
+terrain_streamer EditorTerrain;
+
+void terrain_streamer::configure(int Cells, float CellSize, int Radius, float BaseHeight, std::string const &Texture)
+{
+	m_cells = std::max(1, Cells);
+	m_cellsize = std::max(0.1f, CellSize);
+	m_radius = std::max(0, Radius);
+	m_baseheight = BaseHeight;
+	m_texture = Texture;
+}
+
+terrain_streamer::chunk_key terrain_streamer::key_at(double X, double Z) const
+{
+	double const size = chunk_world_size();
+	return {static_cast<int>(std::floor(X / size)), static_cast<int>(std::floor(Z / size))};
+}
+
+glm::dvec3 terrain_streamer::chunk_centre(int Cx, int Cz) const
+{
+	double const size = chunk_world_size();
+	return glm::dvec3((Cx + 0.5) * size, static_cast<double>(m_baseheight), (Cz + 0.5) * size);
+}
+
+std::string terrain_streamer::chunk_path(int Cx, int Cz) const
+{
+	return m_dir + "/chunk_" + std::to_string(Cx) + "_" + std::to_string(Cz) + ".etc";
+}
+
+bool terrain_streamer::chunk_on_disk(chunk_key const &Key)
+{
+	auto const it = m_known.find(Key);
+	if (it != m_known.end())
+		return (it->second & cf_exists_on_disk) != 0;
+
+	std::error_code ec;
+	bool const exists = std::filesystem::exists(chunk_path(Key.first, Key.second), ec);
+	m_known[Key] = exists ? cf_exists_on_disk : 0;
+	return exists;
+}
+
+// 16-bit chunk file: 'ETC1' | uint16 cells | float baseY | float step | (cells+1)^2 * uint16
+// where worldY = baseY + raw * step (per-chunk auto-scaled to fit the height range losslessly-ish)
+bool terrain_streamer::load_heights(int Cx, int Cz, std::vector<float> &Out) const
+{
+	std::ifstream f(chunk_path(Cx, Cz), std::ios::binary);
+	if (!f)
+		return false;
+
+	char magic[4] = {};
+	f.read(magic, 4);
+	if (f.gcount() != 4 || magic[0] != 'E' || magic[1] != 'T' || magic[2] != 'C' || magic[3] != '1')
+		return false;
+
+	std::uint16_t cells = 0;
+	float baseY = 0.0f, step = 0.0f;
+	f.read(reinterpret_cast<char *>(&cells), sizeof(cells));
+	f.read(reinterpret_cast<char *>(&baseY), sizeof(baseY));
+	f.read(reinterpret_cast<char *>(&step), sizeof(step));
+	if (!f || static_cast<int>(cells) != m_cells)
+		return false; // resolution changed since save: ignore and regenerate
+
+	std::size_t const n = static_cast<std::size_t>(cells + 1) * (cells + 1);
+	Out.resize(n);
+	for (std::size_t i = 0; i < n; ++i)
+	{
+		std::uint16_t raw = 0;
+		f.read(reinterpret_cast<char *>(&raw), sizeof(raw));
+		if (!f)
+			return false;
+		Out[i] = baseY + static_cast<float>(raw) * step;
+	}
+	return true;
+}
+
+void terrain_streamer::save_heights(int Cx, int Cz, editor_terrain const &Terrain)
+{
+	auto const &h = Terrain.heights();
+	if (h.empty())
+		return;
+
+	float minh = h[0], maxh = h[0];
+	for (float const v : h)
+	{
+		minh = std::min(minh, v);
+		maxh = std::max(maxh, v);
+	}
+	float const step = (maxh > minh) ? (maxh - minh) / 65535.0f : 0.0f;
+
+	std::error_code ec;
+	std::filesystem::create_directories(m_dir, ec);
+	std::ofstream f(chunk_path(Cx, Cz), std::ios::binary | std::ios::trunc);
+	if (!f)
+		return;
+
+	char const magic[4] = {'E', 'T', 'C', '1'};
+	std::uint16_t const cells = static_cast<std::uint16_t>(Terrain.cells());
+	f.write(magic, 4);
+	f.write(reinterpret_cast<char const *>(&cells), sizeof(cells));
+	f.write(reinterpret_cast<char const *>(&minh), sizeof(minh));
+	f.write(reinterpret_cast<char const *>(&step), sizeof(step));
+	for (float const v : h)
+	{
+		std::uint16_t const raw = (step > 0.0f)
+		                              ? static_cast<std::uint16_t>(std::lround((v - minh) / step))
+		                              : std::uint16_t{0};
+		f.write(reinterpret_cast<char const *>(&raw), sizeof(raw));
+	}
+}
+
+void terrain_streamer::update(glm::dvec3 const &CameraPos)
+{
+	if (!m_active)
+		return;
+
+	chunk_key const camera = key_at(CameraPos.x, CameraPos.z);
+
+	// load any missing chunk inside the radius (one build per frame keeps the hitch small)
+	bool built = false;
+	for (int dz = -m_radius; dz <= m_radius && !built; ++dz)
+		for (int dx = -m_radius; dx <= m_radius && !built; ++dx)
+		{
+			chunk_key const key{camera.first + dx, camera.second + dz};
+			if (m_chunks.count(key))
+				continue;
+
+			// only stream chunks that were actually authored (exist on disk); empty space stays empty
+			std::vector<float> loaded;
+			if (!chunk_on_disk(key) || !load_heights(key.first, key.second, loaded))
+				continue;
+
+			glm::dvec3 const centre = chunk_centre(key.first, key.second);
+			double const size = chunk_world_size();
+			double const x0 = key.first * size, z0 = key.second * size; // chunk corner
+			int const cells = m_cells;
+			float const cs = m_cellsize;
+			editor_terrain::height_sampler sampler =
+			    [&loaded, x0, z0, cells, cs](double X, double Z, double &OutY) -> bool {
+				int ix = static_cast<int>(std::lround((X - x0) / cs));
+				int iz = static_cast<int>(std::lround((Z - z0) / cs));
+				ix = std::clamp(ix, 0, cells);
+				iz = std::clamp(iz, 0, cells);
+				OutY = loaded[static_cast<std::size_t>(iz) * (cells + 1) + ix];
+				return true;
+			};
+
+			auto terrain = std::make_unique<editor_terrain>();
+			if (terrain->create(centre, m_cells, m_cellsize, m_texture, sampler))
+			{
+				if (m_auto_optimize)
+					terrain->optimize(m_simplify_error);
+				m_chunks.emplace(key, std::move(terrain));
+				built = true; // amortise: at most one new chunk per frame
+			}
+		}
+
+	// unload chunks that drifted outside the radius
+	for (auto it = m_chunks.begin(); it != m_chunks.end();)
+	{
+		int const dx = it->first.first - camera.first;
+		int const dz = it->first.second - camera.second;
+		if (std::abs(dx) > m_radius || std::abs(dz) > m_radius)
+		{
+			if (it->second)
+			{
+				// persist edits before dropping the chunk, so they survive the round-trip
+				if (m_persist && it->second->modified())
+				{
+					save_heights(it->first.first, it->first.second, *it->second);
+					m_known[it->first] |= cf_exists_on_disk;
+				}
+				it->second->destroy();
+			}
+			it = m_chunks.erase(it);
+		}
+		else
+			++it;
+	}
+}
+
+void terrain_streamer::clear()
+{
+	for (auto &entry : m_chunks)
+		if (entry.second)
+		{
+			if (m_persist && entry.second->modified())
+			{
+				save_heights(entry.first.first, entry.first.second, *entry.second);
+				m_known[entry.first] |= cf_exists_on_disk;
+			}
+			entry.second->destroy();
+		}
+	m_chunks.clear();
+}
+
+void terrain_streamer::collect(std::vector<editor_terrain *> &Out) const
+{
+	for (auto const &entry : m_chunks)
+		if (entry.second)
+			Out.push_back(entry.second.get());
+}
+
+editor_terrain *terrain_streamer::terrain_at(double X, double Z) const
+{
+	auto const it = m_chunks.find(key_at(X, Z));
+	if (it != m_chunks.end() && it->second && it->second->contains(X, Z))
+		return it->second.get();
+	return nullptr;
+}
+
+void terrain_streamer::save_chunk(int Cx, int Cz, editor_terrain const &Terrain)
+{
+	save_heights(Cx, Cz, Terrain);
+	m_known[{Cx, Cz}] |= cf_exists_on_disk;
+}
+
+void terrain_streamer::add_chunk(int Cx, int Cz)
+{
+	chunk_key const key{Cx, Cz};
+	if (m_chunks.count(key))
+		return; // already resident
+
+	glm::dvec3 const centre = chunk_centre(Cx, Cz);
+	auto terrain = std::make_unique<editor_terrain>();
+	if (!terrain->create(centre, m_cells, m_cellsize, m_texture)) // flat
+		return;
+
+	// persist immediately so it becomes part of the authored, streamable world
+	save_heights(Cx, Cz, *terrain);
+	m_known[key] |= cf_exists_on_disk;
+
+	if (m_auto_optimize)
+		terrain->optimize(m_simplify_error);
+	m_chunks.emplace(key, std::move(terrain));
+}
+
+void terrain_streamer::reset()
+{
+	// do NOT call editor_terrain::destroy() here: on a scenery reload the sections those chunks
+	// referenced are already gone. just drop our bookkeeping; the old region freed the shapes.
+	m_chunks.clear();
+	m_known.clear();
+	m_active = false;
+}
+
+void terrain_streamer::flush()
+{
+	for (auto &entry : m_chunks)
+		if (entry.second && entry.second->modified())
+		{
+			save_heights(entry.first.first, entry.first.second, *entry.second);
+			m_known[entry.first] |= cf_exists_on_disk;
+			entry.second->clear_modified();
+		}
+}
+
+void terrain_streamer::remove_chunk(int Cx, int Cz)
+{
+	chunk_key const key{Cx, Cz};
+	auto const it = m_chunks.find(key);
+	if (it != m_chunks.end())
+	{
+		if (it->second)
+			it->second->destroy();
+		m_chunks.erase(it);
+	}
+	std::error_code ec;
+	std::filesystem::remove(chunk_path(Cx, Cz), ec);
+	m_known[key] = 0; // no longer on disk
+}