From 16bec12e3e75e95d251745f904ac4e15af9c9724 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 28 Oct 2023 02:34:45 +0100
Subject: Initial OpenMesh based terrain data and tests

---
 game/terrain2.cpp | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 game/terrain2.h   | 24 ++++++++++++++++++++
 2 files changed, 90 insertions(+)
 create mode 100644 game/terrain2.cpp
 create mode 100644 game/terrain2.h

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
new file mode 100644
index 0000000..83df3fa
--- /dev/null
+++ b/game/terrain2.cpp
@@ -0,0 +1,66 @@
+#include "terrain2.h"
+#include <fstream>
+
+TerrainMesh::TerrainMesh(const std::filesystem::path & input)
+{
+	size_t ncols = 0, nrows = 0, xllcorner = 0, yllcorner = 0, cellsize = 0;
+	std::map<std::string_view, size_t *> properties {
+			{"ncols", &ncols},
+			{"nrows", &nrows},
+			{"xllcorner", &xllcorner},
+			{"yllcorner", &yllcorner},
+			{"cellsize", &cellsize},
+	};
+	std::ifstream f {input};
+	while (!properties.empty()) {
+		std::string property;
+		f >> property;
+		f >> *properties.at(property);
+		properties.erase(property);
+	}
+	std::vector<VertexHandle> vertices;
+	vertices.reserve(ncols * nrows);
+	for (size_t row = 0; row < nrows; ++row) {
+		for (size_t col = 0; col < ncols; ++col) {
+			float height = 0;
+			f >> height;
+			vertices.push_back(add_vertex({xllcorner + (col * cellsize), yllcorner + (row * cellsize), height}));
+		}
+	}
+	if (!f.good()) {
+		throw std::runtime_error("Couldn't read terrain file");
+	}
+	for (size_t row = 1; row < nrows; ++row) {
+		for (size_t col = 1; col < ncols; ++col) {
+			add_face({
+					vertices[ncols * (row - 1) + (col - 1)],
+					vertices[ncols * (row - 0) + (col - 0)],
+					vertices[ncols * (row - 0) + (col - 1)],
+			});
+			add_face({
+					vertices[ncols * (row - 1) + (col - 1)],
+					vertices[ncols * (row - 1) + (col - 0)],
+					vertices[ncols * (row - 0) + (col - 0)],
+			});
+		}
+	}
+	update_face_normals();
+	update_vertex_normals();
+};
+
+bool
+TerrainMesh::triangleContainsPoint(const glm::vec2 p, const glm::vec2 a, const glm::vec2 b, const glm::vec2 c)
+{
+	const auto det = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+
+	return det * ((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x)) >= 0
+			&& det * ((c.x - b.x) * (p.y - b.y) - (c.y - b.y) * (p.x - b.x)) >= 0
+			&& det * ((a.x - c.x) * (p.y - c.y) - (a.y - c.y) * (p.x - c.x)) >= 0;
+}
+
+bool
+TerrainMesh::triangleContainsPoint(const glm::vec2 p, FaceHandle face) const
+{
+	auto vertices = cfv_iter(face);
+	return triangleContainsPoint(p, point(*vertices++), point(*vertices++), point(*vertices++));
+}
diff --git a/game/terrain2.h b/game/terrain2.h
new file mode 100644
index 0000000..d2da8d0
--- /dev/null
+++ b/game/terrain2.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>
+#include <filesystem>
+#include <glm/vec2.hpp>
+#include <thirdparty/openmesh/glmcompat.h>
+
+struct TerrainTraits : public OpenMesh::DefaultTraits {
+	FaceAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
+	EdgeAttributes(OpenMesh::Attributes::Status);
+	VertexAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
+	HalfedgeAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
+	using Point = glm::vec3;
+	using Normal = glm::vec3;
+};
+
+class TerrainMesh : public OpenMesh::TriMesh_ArrayKernelT<TerrainTraits> {
+public:
+	explicit TerrainMesh(const std::filesystem::path &);
+
+protected:
+	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
+	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
+};
-- 
cgit v1.2.3


From 49a422ed91289a31142a8c0fb8b7030d2dea98a1 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 29 Oct 2023 14:11:46 +0000
Subject: Initial commit of findPoint on terrain

2D navigate from a default/given starting point, possible scope for improvement, but it's
not exactly slow; <9ms
---
 game/terrain2.cpp     | 33 ++++++++++++++++++++++++++++++++-
 game/terrain2.h       |  4 ++++
 test/Jamfile.jam      |  4 +++-
 test/perf-terrain.cpp | 18 ++++++++++++++++++
 test/test-terrain.cpp | 19 +++++++++++++++++++
 5 files changed, 76 insertions(+), 2 deletions(-)
 create mode 100644 test/perf-terrain.cpp

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
index 83df3fa..cc0bf90 100644
--- a/game/terrain2.cpp
+++ b/game/terrain2.cpp
@@ -48,6 +48,32 @@ TerrainMesh::TerrainMesh(const std::filesystem::path & input)
 	update_vertex_normals();
 };
 
+OpenMesh::FaceHandle
+TerrainMesh::findPoint(glm::vec2 p) const
+{
+	return findPoint(p, *faces_begin());
+}
+
+OpenMesh::FaceHandle
+TerrainMesh::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const
+{
+	ConstFaceVertexIter vertices;
+	while (f.is_valid() && !triangleContainsPoint(p, vertices = cfv_iter(f))) {
+		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
+			f = opposite_face_handle(*next);
+			if (f.is_valid()) {
+				const auto e1 = point(to_vertex_handle(*next));
+				const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next)));
+				if ((e2.x - e1.x) * (p.y - e1.y) > (e2.y - e1.y) * (p.x - e1.x)) {
+					break;
+				}
+			}
+			f.reset();
+		}
+	}
+	return f;
+}
+
 bool
 TerrainMesh::triangleContainsPoint(const glm::vec2 p, const glm::vec2 a, const glm::vec2 b, const glm::vec2 c)
 {
@@ -61,6 +87,11 @@ TerrainMesh::triangleContainsPoint(const glm::vec2 p, const glm::vec2 a, const g
 bool
 TerrainMesh::triangleContainsPoint(const glm::vec2 p, FaceHandle face) const
 {
-	auto vertices = cfv_iter(face);
+	return triangleContainsPoint(p, cfv_iter(face));
+}
+
+bool
+TerrainMesh::triangleContainsPoint(const glm::vec2 p, ConstFaceVertexIter vertices) const
+{
 	return triangleContainsPoint(p, point(*vertices++), point(*vertices++), point(*vertices++));
 }
diff --git a/game/terrain2.h b/game/terrain2.h
index d2da8d0..713fe23 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -18,7 +18,11 @@ class TerrainMesh : public OpenMesh::TriMesh_ArrayKernelT<TerrainTraits> {
 public:
 	explicit TerrainMesh(const std::filesystem::path &);
 
+	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
+	[[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const;
+
 protected:
 	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
+	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, ConstFaceVertexIter) const;
 };
diff --git a/test/Jamfile.jam b/test/Jamfile.jam
index eab3996..7fa7bfc 100644
--- a/test/Jamfile.jam
+++ b/test/Jamfile.jam
@@ -61,9 +61,11 @@ run test-instancing.cpp : : : <library>test ;
 run test-glContainer.cpp : : : <library>test ;
 run test-pack.cpp : : : <library>test ;
 run test-terrain.cpp : : : <library>test <library>..//OpenMeshCore ;
+run perf-terrain.cpp : : : <library>test <library>..//OpenMeshCore <library>benchmark ;
 compile test-static-enumDetails.cpp ;
 compile test-static-stream_support.cpp ;
 explicit perf-assetFactory ;
 explicit perf-persistence ;
-alias perf : perf-assetFactory perf-persistence ;
+explicit perf-terrain ;
+alias perf : perf-assetFactory perf-persistence perf-terrain ;
 explicit perf ;
diff --git a/test/perf-terrain.cpp b/test/perf-terrain.cpp
new file mode 100644
index 0000000..e998f60
--- /dev/null
+++ b/test/perf-terrain.cpp
@@ -0,0 +1,18 @@
+#include <benchmark/benchmark.h>
+#include <game/terrain2.h>
+
+namespace {
+	const TerrainMesh tm {FIXTURESDIR "height/SD19.asc"};
+
+	void
+	terrain_findPoint(benchmark::State & state)
+	{
+		for (auto _ : state) {
+			benchmark::DoNotOptimize(tm.findPoint({315555, 495556}));
+		}
+	}
+}
+
+BENCHMARK(terrain_findPoint);
+
+BENCHMARK_MAIN();
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
index b2358d6..d062853 100644
--- a/test/test-terrain.cpp
+++ b/test/test-terrain.cpp
@@ -1,4 +1,5 @@
 #define BOOST_TEST_MODULE terrain
+#include <boost/test/data/test_case.hpp>
 #include <boost/test/unit_test.hpp>
 #include <stream_support.h>
 
@@ -46,3 +47,21 @@ BOOST_AUTO_TEST_CASE(trianglesContainsPoints)
 }
 
 BOOST_AUTO_TEST_SUITE_END();
+
+using FindPointData = std::tuple<glm::vec2, int>;
+
+static const TestTerrainMesh fixedTerrtain;
+
+// No boundary cases as these can produce different valid results depending on starting point
+BOOST_DATA_TEST_CASE(findPointOnTerrain,
+		boost::unit_test::data::make<FindPointData>({
+				{{0, 0}, -1}, {{xllcorner, 0}, -1}, {{0, yllcorner}, -1}, {{xllcorner + 1, yllcorner + 2}, 0},
+				{{xllcorner + (cellsize * (nrows - 1)) - 2, yllcorner + (cellsize * (ncols - 1)) - 1}, 79200},
+				{{315555, 495556}, 44400}, // perf test target
+		})
+				* boost::unit_test::data::make<int>(
+						{0, 1, 2, 3, 4, 5, 6, 10, 100, 150, 200, 1000, 1234, 17439, 79201, 79200, 79199}),
+		p, fh, start)
+{
+	BOOST_CHECK_EQUAL(fh, fixedTerrtain.findPoint(p, TerrainMesh::FaceHandle(start)).idx());
+}
-- 
cgit v1.2.3


From 583aa8eb078090fd48c6d6db8ee69da5ad8811fb Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Tue, 31 Oct 2023 00:29:35 +0000
Subject: Initial commit of walk/walkUtil terrain

---
 game/terrain2.cpp     | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 game/terrain2.h       |  3 +++
 test/test-terrain.cpp | 41 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 98 insertions(+), 1 deletion(-)

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
index cc0bf90..3e24778 100644
--- a/game/terrain2.cpp
+++ b/game/terrain2.cpp
@@ -54,6 +54,28 @@ TerrainMesh::findPoint(glm::vec2 p) const
 	return findPoint(p, *faces_begin());
 }
 
+namespace {
+	[[nodiscard]] constexpr inline bool
+	pointLeftOfLine(const glm::vec2 p, const glm::vec2 e1, const glm::vec2 e2)
+	{
+		return (e2.x - e1.x) * (p.y - e1.y) > (e2.y - e1.y) * (p.x - e1.x);
+	}
+
+	static_assert(pointLeftOfLine({1, 2}, {1, 1}, {2, 2}));
+	static_assert(pointLeftOfLine({2, 1}, {2, 2}, {1, 1}));
+	static_assert(pointLeftOfLine({2, 2}, {1, 2}, {2, 1}));
+	static_assert(pointLeftOfLine({1, 1}, {2, 1}, {1, 2}));
+
+	[[nodiscard]] constexpr inline bool
+	linesCross(const glm::vec2 a1, const glm::vec2 a2, const glm::vec2 b1, const glm::vec2 b2)
+	{
+		return pointLeftOfLine(a2, b1, b2) && pointLeftOfLine(a1, b2, b1) && pointLeftOfLine(b1, a1, a2)
+				&& pointLeftOfLine(b2, a2, a1);
+	}
+
+	static_assert(linesCross({1, 1}, {2, 2}, {1, 2}, {2, 1}));
+}
+
 OpenMesh::FaceHandle
 TerrainMesh::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const
 {
@@ -64,7 +86,7 @@ TerrainMesh::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const
 			if (f.is_valid()) {
 				const auto e1 = point(to_vertex_handle(*next));
 				const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next)));
-				if ((e2.x - e1.x) * (p.y - e1.y) > (e2.y - e1.y) * (p.x - e1.x)) {
+				if (pointLeftOfLine(p, e1, e2)) {
 					break;
 				}
 			}
@@ -74,6 +96,37 @@ TerrainMesh::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const
 	return f;
 }
 
+void
+TerrainMesh::walk(const glm::vec2 from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const
+{
+	walkUntil(from, to, [&op](const auto & fh) {
+		op(fh);
+		return false;
+	});
+}
+
+void
+TerrainMesh::walkUntil(const glm::vec2 from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const
+{
+	auto f = findPoint(from);
+	assert(f.is_valid()); // TODO replace with a boundary search
+	FaceHandle previousFace;
+	while (f.is_valid() && !op(f)) {
+		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
+			f = opposite_face_handle(*next);
+			if (f.is_valid() && f != previousFace) {
+				const auto e1 = point(to_vertex_handle(*next));
+				const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next)));
+				if (linesCross(from, to, e1, e2)) {
+					previousFace = f;
+					break;
+				}
+			}
+			f.reset();
+		}
+	}
+}
+
 bool
 TerrainMesh::triangleContainsPoint(const glm::vec2 p, const glm::vec2 a, const glm::vec2 b, const glm::vec2 c)
 {
diff --git a/game/terrain2.h b/game/terrain2.h
index 713fe23..848c36e 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -21,6 +21,9 @@ public:
 	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
 	[[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const;
 
+	void walk(const glm::vec2 from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const;
+	void walkUntil(const glm::vec2 from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const;
+
 protected:
 	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
index d062853..429207c 100644
--- a/test/test-terrain.cpp
+++ b/test/test-terrain.cpp
@@ -65,3 +65,44 @@ BOOST_DATA_TEST_CASE(findPointOnTerrain,
 {
 	BOOST_CHECK_EQUAL(fh, fixedTerrtain.findPoint(p, TerrainMesh::FaceHandle(start)).idx());
 }
+
+using WalkTerrainData = std::tuple<glm::vec2, glm::vec2, std::vector<int>>;
+
+BOOST_DATA_TEST_CASE(walkTerrain,
+		boost::unit_test::data::make<WalkTerrainData>({
+				{{310002, 490003}, {310002, 490003}, {0}},
+				{{310003, 490002}, {310003, 490002}, {1}},
+				{{310002, 490003}, {310003, 490002}, {0, 1}},
+				{{310003, 490002}, {310002, 490003}, {1, 0}},
+				{{310002, 490003}, {310202, 490003}, {0, 1, 2, 3, 4, 5, 6, 7, 8}},
+				{{310202, 490003}, {310002, 490003}, {8, 7, 6, 5, 4, 3, 2, 1, 0}},
+				{{310002, 490003}, {310002, 490203}, {0, 399, 398, 797, 796, 1195, 1194, 1593, 1592}},
+		}),
+		from, to, visits)
+{
+	std::vector<int> visited;
+	BOOST_CHECK_NO_THROW(fixedTerrtain.walk(from, to, [&visited](auto fh) {
+		visited.emplace_back(fh.idx());
+	}));
+	BOOST_CHECK_EQUAL_COLLECTIONS(visited.begin(), visited.end(), visits.begin(), visits.end());
+}
+
+BOOST_DATA_TEST_CASE(walkTerrainUntil,
+		boost::unit_test::data::make<WalkTerrainData>({
+				{{310002, 490003}, {310002, 490003}, {0}},
+				{{310003, 490002}, {310003, 490002}, {1}},
+				{{310002, 490003}, {310003, 490002}, {0, 1}},
+				{{310003, 490002}, {310002, 490003}, {1, 0}},
+				{{310002, 490003}, {310202, 490003}, {0, 1, 2, 3, 4}},
+				{{310202, 490003}, {310002, 490003}, {8, 7, 6, 5, 4}},
+				{{310002, 490003}, {310002, 490203}, {0, 399, 398, 797, 796}},
+		}),
+		from, to, visits)
+{
+	std::vector<int> visited;
+	BOOST_CHECK_NO_THROW(fixedTerrtain.walkUntil(from, to, [&visited](auto fh) {
+		visited.emplace_back(fh.idx());
+		return visited.size() >= 5;
+	}));
+	BOOST_CHECK_EQUAL_COLLECTIONS(visited.begin(), visited.end(), visits.begin(), visits.end());
+}
-- 
cgit v1.2.3


From a0f1dc90aabd4cb5cfe2aef7116af170e6d0b953 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Tue, 31 Oct 2023 01:26:58 +0000
Subject: Helper type for storing/passing/returning a point and its containing
 face

point is const as face is mutable as a cache of the face containing
point.
---
 game/terrain2.cpp     | 18 ++++++++++++++++++
 game/terrain2.h       | 10 ++++++++++
 test/test-terrain.cpp |  9 +++++++++
 3 files changed, 37 insertions(+)

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
index 3e24778..e98cebb 100644
--- a/game/terrain2.cpp
+++ b/game/terrain2.cpp
@@ -54,6 +54,24 @@ TerrainMesh::findPoint(glm::vec2 p) const
 	return findPoint(p, *faces_begin());
 }
 
+bool
+TerrainMesh::locate(const TerrainMesh::PointFace & pointFace, FaceHandle start) const
+{
+	if (pointFace.face.is_valid()) {
+		assert(triangleContainsPoint(pointFace.point, pointFace.face));
+		return true;
+	}
+	else {
+		return (pointFace.face = findPoint(pointFace.point, start)).is_valid();
+	}
+}
+
+bool
+TerrainMesh::locate(const TerrainMesh::PointFace & pointFace) const
+{
+	return locate(pointFace, *faces_begin());
+}
+
 namespace {
 	[[nodiscard]] constexpr inline bool
 	pointLeftOfLine(const glm::vec2 p, const glm::vec2 e1, const glm::vec2 e2)
diff --git a/game/terrain2.h b/game/terrain2.h
index 848c36e..e516719 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -18,6 +18,13 @@ class TerrainMesh : public OpenMesh::TriMesh_ArrayKernelT<TerrainTraits> {
 public:
 	explicit TerrainMesh(const std::filesystem::path &);
 
+	struct PointFace {
+		PointFace(const glm::vec2 p) : point {p} { }
+
+		const glm::vec2 point;
+		mutable FaceHandle face {};
+	};
+
 	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
 	[[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const;
 
@@ -28,4 +35,7 @@ protected:
 	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, ConstFaceVertexIter) const;
+
+	bool locate(const PointFace &) const;
+	bool locate(const PointFace &, FaceHandle start) const;
 };
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
index 429207c..f737f4f 100644
--- a/test/test-terrain.cpp
+++ b/test/test-terrain.cpp
@@ -46,6 +46,15 @@ BOOST_AUTO_TEST_CASE(trianglesContainsPoints)
 	}
 }
 
+BOOST_AUTO_TEST_CASE(locatePointFace)
+{
+	const PointFace pf {{310002, 490003}};
+	BOOST_CHECK(!pf.face.is_valid());
+	BOOST_CHECK(locate(pf));
+	BOOST_CHECK(pf.face.is_valid());
+	BOOST_CHECK_EQUAL(pf.face.idx(), 0);
+}
+
 BOOST_AUTO_TEST_SUITE_END();
 
 using FindPointData = std::tuple<glm::vec2, int>;
-- 
cgit v1.2.3


From a4f1c55ad34f6be9adc9573fd7f26507ae2c59b0 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Tue, 31 Oct 2023 02:40:03 +0000
Subject: Update walk/walkUntil to work on PointFace from parameter

---
 game/terrain2.cpp     | 11 ++++++-----
 game/terrain2.h       |  4 ++--
 test/test-terrain.cpp | 14 ++++++++++++++
 3 files changed, 22 insertions(+), 7 deletions(-)

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
index e98cebb..5d1c595 100644
--- a/game/terrain2.cpp
+++ b/game/terrain2.cpp
@@ -115,7 +115,7 @@ TerrainMesh::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const
 }
 
 void
-TerrainMesh::walk(const glm::vec2 from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const
+TerrainMesh::walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const
 {
 	walkUntil(from, to, [&op](const auto & fh) {
 		op(fh);
@@ -124,10 +124,11 @@ TerrainMesh::walk(const glm::vec2 from, const glm::vec2 to, const std::function<
 }
 
 void
-TerrainMesh::walkUntil(const glm::vec2 from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const
+TerrainMesh::walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const
 {
-	auto f = findPoint(from);
-	assert(f.is_valid()); // TODO replace with a boundary search
+	locate(from);
+	assert(from.face.is_valid()); // TODO replace with a boundary search
+	auto f = from.face;
 	FaceHandle previousFace;
 	while (f.is_valid() && !op(f)) {
 		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
@@ -135,7 +136,7 @@ TerrainMesh::walkUntil(const glm::vec2 from, const glm::vec2 to, const std::func
 			if (f.is_valid() && f != previousFace) {
 				const auto e1 = point(to_vertex_handle(*next));
 				const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next)));
-				if (linesCross(from, to, e1, e2)) {
+				if (linesCross(from.point, to, e1, e2)) {
 					previousFace = f;
 					break;
 				}
diff --git a/game/terrain2.h b/game/terrain2.h
index e516719..1a4e263 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -28,8 +28,8 @@ public:
 	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
 	[[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const;
 
-	void walk(const glm::vec2 from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const;
-	void walkUntil(const glm::vec2 from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const;
+	void walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const;
+	void walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const;
 
 protected:
 	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
index f737f4f..bf30179 100644
--- a/test/test-terrain.cpp
+++ b/test/test-terrain.cpp
@@ -96,6 +96,20 @@ BOOST_DATA_TEST_CASE(walkTerrain,
 	BOOST_CHECK_EQUAL_COLLECTIONS(visited.begin(), visited.end(), visits.begin(), visits.end());
 }
 
+BOOST_DATA_TEST_CASE(walkTerrainSetsFromFace,
+		boost::unit_test::data::make<WalkTerrainData>({
+				{{310002, 490003}, {310002, 490003}, {0}},
+				{{310003, 490002}, {310003, 490002}, {1}},
+				{{310002, 490003}, {310003, 490002}, {0, 1}},
+				{{310003, 490002}, {310002, 490003}, {1, 0}},
+		}),
+		from, to, visits)
+{
+	TerrainMesh::PointFace pf {from};
+	BOOST_CHECK_NO_THROW(fixedTerrtain.walk(pf, to, [](auto) {}));
+	BOOST_CHECK_EQUAL(pf.face.idx(), visits.front());
+}
+
 BOOST_DATA_TEST_CASE(walkTerrainUntil,
 		boost::unit_test::data::make<WalkTerrainData>({
 				{{310002, 490003}, {310002, 490003}, {0}},
-- 
cgit v1.2.3


From b46cf55d66f262778bf0353650f00620c7740f2a Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Tue, 31 Oct 2023 19:36:16 +0000
Subject: Make PointFace harder to misuse

---
 game/terrain2.cpp     | 33 +++++++++++++++++++++------------
 game/terrain2.h       | 21 +++++++++++++++++----
 test/test-terrain.cpp | 16 +++++++++++-----
 3 files changed, 49 insertions(+), 21 deletions(-)

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
index 5d1c595..8d29143 100644
--- a/game/terrain2.cpp
+++ b/game/terrain2.cpp
@@ -54,22 +54,32 @@ TerrainMesh::findPoint(glm::vec2 p) const
 	return findPoint(p, *faces_begin());
 }
 
-bool
-TerrainMesh::locate(const TerrainMesh::PointFace & pointFace, FaceHandle start) const
+TerrainMesh::PointFace::PointFace(const glm::vec2 p, const TerrainMesh * mesh) :
+	PointFace {p, mesh, *mesh->faces_begin()}
+{
+}
+
+TerrainMesh::PointFace::PointFace(const glm::vec2 p, const TerrainMesh * mesh, FaceHandle start) :
+	PointFace {p, mesh->findPoint(p, start)}
 {
-	if (pointFace.face.is_valid()) {
-		assert(triangleContainsPoint(pointFace.point, pointFace.face));
-		return true;
+}
+
+TerrainMesh::FaceHandle
+TerrainMesh::PointFace::face(const TerrainMesh * mesh, FaceHandle start) const
+{
+	if (_face.is_valid()) {
+		assert(mesh->triangleContainsPoint(point, _face));
+		return _face;
 	}
 	else {
-		return (pointFace.face = findPoint(pointFace.point, start)).is_valid();
+		return (_face = mesh->findPoint(point, start));
 	}
 }
 
-bool
-TerrainMesh::locate(const TerrainMesh::PointFace & pointFace) const
+TerrainMesh::FaceHandle
+TerrainMesh::PointFace::face(const TerrainMesh * mesh) const
 {
-	return locate(pointFace, *faces_begin());
+	return face(mesh, *mesh->faces_begin());
 }
 
 namespace {
@@ -126,9 +136,8 @@ TerrainMesh::walk(const PointFace & from, const glm::vec2 to, const std::functio
 void
 TerrainMesh::walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const
 {
-	locate(from);
-	assert(from.face.is_valid()); // TODO replace with a boundary search
-	auto f = from.face;
+	assert(from.face(this).is_valid()); // TODO replace with a boundary search
+	auto f = from.face(this);
 	FaceHandle previousFace;
 	while (f.is_valid() && !op(f)) {
 		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
diff --git a/game/terrain2.h b/game/terrain2.h
index 1a4e263..641d608 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -19,10 +19,26 @@ public:
 	explicit TerrainMesh(const std::filesystem::path &);
 
 	struct PointFace {
+		// NOLINTNEXTLINE(hicpp-explicit-conversions)
 		PointFace(const glm::vec2 p) : point {p} { }
 
+		PointFace(const glm::vec2 p, FaceHandle face) : point {p}, _face {face} { }
+
+		PointFace(const glm::vec2 p, const TerrainMesh *);
+		PointFace(const glm::vec2 p, const TerrainMesh *, FaceHandle start);
+
 		const glm::vec2 point;
-		mutable FaceHandle face {};
+		[[nodiscard]] FaceHandle face(const TerrainMesh *) const;
+		[[nodiscard]] FaceHandle face(const TerrainMesh *, FaceHandle start) const;
+
+		[[nodiscard]] bool
+		isLocated() const
+		{
+			return _face.is_valid();
+		}
+
+	private:
+		mutable FaceHandle _face {};
 	};
 
 	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
@@ -35,7 +51,4 @@ protected:
 	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, ConstFaceVertexIter) const;
-
-	bool locate(const PointFace &) const;
-	bool locate(const PointFace &, FaceHandle start) const;
 };
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
index bf30179..bf73356 100644
--- a/test/test-terrain.cpp
+++ b/test/test-terrain.cpp
@@ -49,10 +49,16 @@ BOOST_AUTO_TEST_CASE(trianglesContainsPoints)
 BOOST_AUTO_TEST_CASE(locatePointFace)
 {
 	const PointFace pf {{310002, 490003}};
-	BOOST_CHECK(!pf.face.is_valid());
-	BOOST_CHECK(locate(pf));
-	BOOST_CHECK(pf.face.is_valid());
-	BOOST_CHECK_EQUAL(pf.face.idx(), 0);
+	BOOST_CHECK(!pf.isLocated());
+	BOOST_CHECK(pf.face(this).is_valid());
+	BOOST_CHECK_EQUAL(pf.face(this).idx(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(preLocatePointFace)
+{
+	const PointFace pf {{310002, 490003}, this};
+	BOOST_CHECK(pf.isLocated());
+	BOOST_CHECK_EQUAL(pf.face(this).idx(), 0);
 }
 
 BOOST_AUTO_TEST_SUITE_END();
@@ -107,7 +113,7 @@ BOOST_DATA_TEST_CASE(walkTerrainSetsFromFace,
 {
 	TerrainMesh::PointFace pf {from};
 	BOOST_CHECK_NO_THROW(fixedTerrtain.walk(pf, to, [](auto) {}));
-	BOOST_CHECK_EQUAL(pf.face.idx(), visits.front());
+	BOOST_CHECK_EQUAL(pf.face(&fixedTerrtain).idx(), visits.front());
 }
 
 BOOST_DATA_TEST_CASE(walkTerrainUntil,
-- 
cgit v1.2.3


From 1117f91396da00fc48158866ff0ffd1883c4cbd1 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Thu, 2 Nov 2023 20:37:08 +0000
Subject: Generic N-dimensional terrain triangle

---
 game/terrain2.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'game')

diff --git a/game/terrain2.h b/game/terrain2.h
index 641d608..c2c3d19 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "collections.h" // IWYU pragma: keep IterableCollection
 #include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>
 #include <filesystem>
 #include <glm/vec2.hpp>
@@ -41,6 +42,19 @@ public:
 		mutable FaceHandle _face {};
 	};
 
+	template<glm::length_t Dim> struct Triangle : public glm::vec<3, glm::vec<Dim, glm::vec2::value_type>> {
+		using base = glm::vec<3, glm::vec<Dim, glm::vec2::value_type>>;
+		using base::base;
+
+		template<IterableCollection Range> Triangle(const TerrainMesh * m, Range range)
+		{
+			assert(std::distance(range.begin(), range.end()) == 3);
+			std::transform(range.begin(), range.end(), &base::operator[](0), [m](auto vh) {
+				return m->point(vh);
+			});
+		}
+	};
+
 	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
 	[[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const;
 
-- 
cgit v1.2.3


From 8a5d36623e4fa261aea16731954c9987dcbb1ef1 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Thu, 2 Nov 2023 20:38:10 +0000
Subject: Terrain mesh method for getting the height/position at a point on the
 surface

---
 game/terrain2.cpp     | 11 +++++++++++
 game/terrain2.h       |  2 ++
 test/test-terrain.cpp | 23 +++++++++++++++++++++++
 3 files changed, 36 insertions(+)

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
index 8d29143..b129284 100644
--- a/game/terrain2.cpp
+++ b/game/terrain2.cpp
@@ -1,5 +1,7 @@
 #include "terrain2.h"
 #include <fstream>
+#include <glm/gtx/intersect.hpp>
+#include <maths.h>
 
 TerrainMesh::TerrainMesh(const std::filesystem::path & input)
 {
@@ -124,6 +126,15 @@ TerrainMesh::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const
 	return f;
 }
 
+glm::vec3
+TerrainMesh::positionAt(const PointFace & p) const
+{
+	glm::vec3 out {};
+	Triangle<3> t {this, fv_range(p.face(this))};
+	glm::intersectLineTriangle(p.point ^ 0.F, up, t[0], t[1], t[2], out);
+	return p.point ^ out[0];
+}
+
 void
 TerrainMesh::walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const
 {
diff --git a/game/terrain2.h b/game/terrain2.h
index c2c3d19..f1d288e 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -58,6 +58,8 @@ public:
 	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
 	[[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const;
 
+	[[nodiscard]] glm::vec3 positionAt(const PointFace &) const;
+
 	void walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const;
 	void walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const;
 
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
index bf73356..38cb51f 100644
--- a/test/test-terrain.cpp
+++ b/test/test-terrain.cpp
@@ -1,4 +1,5 @@
 #define BOOST_TEST_MODULE terrain
+#include "testHelpers.h"
 #include <boost/test/data/test_case.hpp>
 #include <boost/test/unit_test.hpp>
 #include <stream_support.h>
@@ -81,6 +82,28 @@ BOOST_DATA_TEST_CASE(findPointOnTerrain,
 	BOOST_CHECK_EQUAL(fh, fixedTerrtain.findPoint(p, TerrainMesh::FaceHandle(start)).idx());
 }
 
+using FindPositionData = std::tuple<glm::vec2, float>;
+
+BOOST_DATA_TEST_CASE(findPositionAt,
+		boost::unit_test::data::make<FindPositionData>({
+				// corners
+				{{310000, 490000}, 32.8F},
+				{{310050, 490050}, 33.0F},
+				{{310000, 490050}, 32.7F},
+				{{310050, 490000}, 33.2F},
+				{{310750, 490150}, 58.4F},
+				// midpoints
+				{{310025, 490025}, 32.9F},
+				{{310025, 490050}, 32.85F},
+				{{310000, 490025}, 32.75F},
+				// other
+				{{310751, 490152}, 58.326F},
+		}),
+		p, h)
+{
+	BOOST_CHECK_CLOSE_VEC(fixedTerrtain.positionAt(p), p ^ h);
+}
+
 using WalkTerrainData = std::tuple<glm::vec2, glm::vec2, std::vector<int>>;
 
 BOOST_DATA_TEST_CASE(walkTerrain,
-- 
cgit v1.2.3


From 889baa0abe996976d8717e7e411961804b853465 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Fri, 3 Nov 2023 20:10:56 +0000
Subject: Helper to get cartesian position from baricentric on Triangle

---
 game/terrain2.h | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'game')

diff --git a/game/terrain2.h b/game/terrain2.h
index f1d288e..da9f823 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -53,6 +53,13 @@ public:
 				return m->point(vh);
 			});
 		}
+
+		glm::vec<Dim, glm::vec2::value_type>
+		operator*(glm::vec2 bari) const
+		{
+			const auto & t {*this};
+			return t[0] + ((t[1] - t[0]) * bari.x) + ((t[2] - t[1]) * bari.y);
+		}
 	};
 
 	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
-- 
cgit v1.2.3


From 3931bda936aba6ddae26c1d9f1d450781df800e8 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Fri, 3 Nov 2023 20:12:03 +0000
Subject: Implement terrain intersect ray

---
 game/terrain2.cpp     | 23 +++++++++++++++++++++++
 game/terrain2.h       |  4 ++++
 test/test-terrain.cpp | 12 ++++++++++++
 3 files changed, 39 insertions(+)

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
index b129284..d1af221 100644
--- a/game/terrain2.cpp
+++ b/game/terrain2.cpp
@@ -135,6 +135,29 @@ TerrainMesh::positionAt(const PointFace & p) const
 	return p.point ^ out[0];
 }
 
+[[nodiscard]] std::optional<glm::vec3>
+TerrainMesh::intersectRay(const Ray & ray) const
+{
+	return intersectRay(ray, findPoint(ray.start));
+}
+
+[[nodiscard]] std::optional<glm::vec3>
+TerrainMesh::intersectRay(const Ray & ray, FaceHandle face) const
+{
+	std::optional<glm::vec3> out;
+	walkUntil(PointFace {ray.start, face}, ray.start + (ray.direction * 10000.F), [&out, &ray, this](FaceHandle face) {
+		glm::vec2 bari {};
+		float dist {};
+		Triangle<3> t {this, fv_range(face)};
+		if (glm::intersectRayTriangle(ray.start, ray.direction, t[0], t[1], t[2], bari, dist)) {
+			out = t * bari;
+			return true;
+		}
+		return false;
+	});
+	return out;
+}
+
 void
 TerrainMesh::walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const
 {
diff --git a/game/terrain2.h b/game/terrain2.h
index da9f823..5539a50 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -1,9 +1,11 @@
 #pragma once
 
 #include "collections.h" // IWYU pragma: keep IterableCollection
+#include "ray.h"
 #include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>
 #include <filesystem>
 #include <glm/vec2.hpp>
+#include <optional>
 #include <thirdparty/openmesh/glmcompat.h>
 
 struct TerrainTraits : public OpenMesh::DefaultTraits {
@@ -66,6 +68,8 @@ public:
 	[[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const;
 
 	[[nodiscard]] glm::vec3 positionAt(const PointFace &) const;
+	[[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &) const;
+	[[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &, FaceHandle start) const;
 
 	void walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const;
 	void walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const;
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
index 38cb51f..53eebfb 100644
--- a/test/test-terrain.cpp
+++ b/test/test-terrain.cpp
@@ -104,6 +104,18 @@ BOOST_DATA_TEST_CASE(findPositionAt,
 	BOOST_CHECK_CLOSE_VEC(fixedTerrtain.positionAt(p), p ^ h);
 }
 
+using FindRayIntersectData = std::tuple<glm::vec3, glm::vec3, glm::vec3>;
+
+BOOST_DATA_TEST_CASE(findRayIntersect,
+		boost::unit_test::data::make<FindRayIntersectData>({
+				{{310000, 490000, 50}, {1, 1, -2}, {310008.59, 490008.59, 32.834301}},
+				{{310000, 490000, 50}, {1, 1, -1}, {310017.12, 490017.12, 32.868526}},
+		}),
+		p, d, i)
+{
+	BOOST_CHECK_CLOSE_VEC(fixedTerrtain.intersectRay({p, d}).value(), i);
+}
+
 using WalkTerrainData = std::tuple<glm::vec2, glm::vec2, std::vector<int>>;
 
 BOOST_DATA_TEST_CASE(walkTerrain,
-- 
cgit v1.2.3


From a46fded5d93487974ac5f40ff36c8c0f4f7a9db2 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 4 Nov 2023 11:21:23 +0000
Subject: Static helper for loading ASCII grid data

---
 game/terrain2.cpp     | 16 ++++++++++------
 game/terrain2.h       |  5 ++++-
 test/test-terrain.cpp |  2 +-
 3 files changed, 15 insertions(+), 8 deletions(-)

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
index d1af221..105eb33 100644
--- a/game/terrain2.cpp
+++ b/game/terrain2.cpp
@@ -3,7 +3,8 @@
 #include <glm/gtx/intersect.hpp>
 #include <maths.h>
 
-TerrainMesh::TerrainMesh(const std::filesystem::path & input)
+TerrainMesh
+TerrainMesh::loadFromAsciiGrid(const std::filesystem::path & input)
 {
 	size_t ncols = 0, nrows = 0, xllcorner = 0, yllcorner = 0, cellsize = 0;
 	std::map<std::string_view, size_t *> properties {
@@ -22,11 +23,12 @@ TerrainMesh::TerrainMesh(const std::filesystem::path & input)
 	}
 	std::vector<VertexHandle> vertices;
 	vertices.reserve(ncols * nrows);
+	TerrainMesh mesh;
 	for (size_t row = 0; row < nrows; ++row) {
 		for (size_t col = 0; col < ncols; ++col) {
 			float height = 0;
 			f >> height;
-			vertices.push_back(add_vertex({xllcorner + (col * cellsize), yllcorner + (row * cellsize), height}));
+			vertices.push_back(mesh.add_vertex({xllcorner + (col * cellsize), yllcorner + (row * cellsize), height}));
 		}
 	}
 	if (!f.good()) {
@@ -34,20 +36,22 @@ TerrainMesh::TerrainMesh(const std::filesystem::path & input)
 	}
 	for (size_t row = 1; row < nrows; ++row) {
 		for (size_t col = 1; col < ncols; ++col) {
-			add_face({
+			mesh.add_face({
 					vertices[ncols * (row - 1) + (col - 1)],
 					vertices[ncols * (row - 0) + (col - 0)],
 					vertices[ncols * (row - 0) + (col - 1)],
 			});
-			add_face({
+			mesh.add_face({
 					vertices[ncols * (row - 1) + (col - 1)],
 					vertices[ncols * (row - 1) + (col - 0)],
 					vertices[ncols * (row - 0) + (col - 0)],
 			});
 		}
 	}
-	update_face_normals();
-	update_vertex_normals();
+	mesh.update_face_normals();
+	mesh.update_vertex_normals();
+
+	return mesh;
 };
 
 OpenMesh::FaceHandle
diff --git a/game/terrain2.h b/game/terrain2.h
index 5539a50..69cd380 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -18,8 +18,11 @@ struct TerrainTraits : public OpenMesh::DefaultTraits {
 };
 
 class TerrainMesh : public OpenMesh::TriMesh_ArrayKernelT<TerrainTraits> {
+private:
+	TerrainMesh() = default;
+
 public:
-	explicit TerrainMesh(const std::filesystem::path &);
+	static TerrainMesh loadFromAsciiGrid(const std::filesystem::path &);
 
 	struct PointFace {
 		// NOLINTNEXTLINE(hicpp-explicit-conversions)
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
index 53eebfb..512a90e 100644
--- a/test/test-terrain.cpp
+++ b/test/test-terrain.cpp
@@ -8,7 +8,7 @@
 
 class TestTerrainMesh : public TerrainMesh {
 public:
-	TestTerrainMesh() : TerrainMesh {FIXTURESDIR "height/SD19.asc"} { }
+	TestTerrainMesh() : TerrainMesh {TerrainMesh::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")} { }
 };
 
 constexpr size_t ncols = 200, nrows = 200, xllcorner = 310000, yllcorner = 490000, cellsize = 50;
-- 
cgit v1.2.3


From c463bce75418a145d319f214571e30df311ff8df Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 4 Nov 2023 12:14:59 +0000
Subject: Calculate and expose the extents of the terrain mesh

---
 game/terrain2.cpp     | 5 +++++
 game/terrain2.h       | 9 +++++++++
 test/test-terrain.cpp | 3 +++
 3 files changed, 17 insertions(+)

(limited to 'game')

diff --git a/game/terrain2.cpp b/game/terrain2.cpp
index 105eb33..0e8b78e 100644
--- a/game/terrain2.cpp
+++ b/game/terrain2.cpp
@@ -24,10 +24,15 @@ TerrainMesh::loadFromAsciiGrid(const std::filesystem::path & input)
 	std::vector<VertexHandle> vertices;
 	vertices.reserve(ncols * nrows);
 	TerrainMesh mesh;
+	mesh.lowerExtent = {xllcorner, yllcorner, std::numeric_limits<float>::max()};
+	mesh.upperExtent
+			= {xllcorner + (cellsize * ncols), yllcorner + (cellsize * nrows), std::numeric_limits<float>::min()};
 	for (size_t row = 0; row < nrows; ++row) {
 		for (size_t col = 0; col < ncols; ++col) {
 			float height = 0;
 			f >> height;
+			mesh.upperExtent.z = std::max(mesh.upperExtent.z, height);
+			mesh.lowerExtent.z = std::min(mesh.lowerExtent.z, height);
 			vertices.push_back(mesh.add_vertex({xllcorner + (col * cellsize), yllcorner + (row * cellsize), height}));
 		}
 	}
diff --git a/game/terrain2.h b/game/terrain2.h
index 69cd380..eda56d0 100644
--- a/game/terrain2.h
+++ b/game/terrain2.h
@@ -77,8 +77,17 @@ public:
 	void walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const;
 	void walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const;
 
+	[[nodiscard]] auto
+	getExtents() const
+	{
+		return std::tie(lowerExtent, upperExtent);
+	}
+
 protected:
 	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, ConstFaceVertexIter) const;
+
+private:
+	glm::vec3 lowerExtent {}, upperExtent {};
 };
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
index 512a90e..71fc1ec 100644
--- a/test/test-terrain.cpp
+++ b/test/test-terrain.cpp
@@ -19,6 +19,9 @@ BOOST_AUTO_TEST_CASE(loadSuccess)
 {
 	BOOST_CHECK_EQUAL(ncols * nrows, n_vertices());
 	BOOST_CHECK_EQUAL(2 * (ncols - 1) * (nrows - 1), n_faces());
+	const auto [lower, upper] = getExtents();
+	BOOST_CHECK_EQUAL(lower, glm::vec3(310000, 490000, -2.6));
+	BOOST_CHECK_EQUAL(upper, glm::vec3(320000, 500000, 571.6));
 }
 
 BOOST_AUTO_TEST_CASE(normalsAllPointUp)
-- 
cgit v1.2.3


From 582ac127f763f512c45f35e17b768487e3b51796 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 4 Nov 2023 17:07:58 +0000
Subject: Rename TerrainMesh to GeoData to drop inplace

---
 Jamroot.jam           |   1 +
 application/main.cpp  |  16 +--
 game/geoData.cpp      | 340 +++++++++++++++++++++++++++-----------------------
 game/geoData.h        | 115 +++++++++++------
 game/terrain.cpp      |  65 +++-------
 game/terrain2.cpp     | 221 --------------------------------
 game/terrain2.h       |  93 --------------
 test/Jamfile.jam      |   5 +-
 test/perf-geoData.cpp |  18 +++
 test/perf-terrain.cpp |  18 ---
 test/test-geo.cpp     | 225 ---------------------------------
 test/test-geoData.cpp | 175 ++++++++++++++++++++++++++
 test/test-render.cpp  |   3 +-
 test/test-terrain.cpp | 175 --------------------------
 ui/gameMainWindow.cpp |   2 +-
 15 files changed, 480 insertions(+), 992 deletions(-)
 delete mode 100644 game/terrain2.cpp
 delete mode 100644 game/terrain2.h
 create mode 100644 test/perf-geoData.cpp
 delete mode 100644 test/perf-terrain.cpp
 delete mode 100644 test/test-geo.cpp
 create mode 100644 test/test-geoData.cpp
 delete mode 100644 test/test-terrain.cpp

(limited to 'game')

diff --git a/Jamroot.jam b/Jamroot.jam
index 8a111ee..ef2f4c2 100644
--- a/Jamroot.jam
+++ b/Jamroot.jam
@@ -101,6 +101,7 @@ lib ilt :
 	<include>.
 	<include>lib
 	<implicit-dependency>thirdparty//glad
+	<library>OpenMeshCore
 	;
 
 build-project test ;
diff --git a/application/main.cpp b/application/main.cpp
index 532c23d..9e4ca33 100644
--- a/application/main.cpp
+++ b/application/main.cpp
@@ -34,11 +34,11 @@ static const int DISPLAY_HEIGHT = 1024;
 class MainApplication : public GameState, public ApplicationBase {
 public:
 	using Windows = Collection<Window>;
+
 	int
 	run()
 	{
-		geoData = std::make_shared<GeoData>(GeoData::Limits {{-120, -120}, {120, 120}}, 10.F);
-		geoData->generateRandom();
+		geoData = std::make_shared<GeoData>(GeoData::loadFromAsciiGrid("test/fixtures/height/SD19.asc"));
 
 		Windows windows;
 		windows.create<GameMainWindow>(DISPLAY_WIDTH, DISPLAY_HEIGHT);
@@ -78,12 +78,12 @@ public:
 			train->orders.create<GoTo>(&train->orders, l3->ends[1], l3->length, rl->findNodeAt({-1100, -450, 15}));
 			train->currentActivity = train->orders.current()->createActivity();
 
-			auto foliage = std::dynamic_pointer_cast<Foliage>(assets.at("Tree-01-1"));
-			for (float x = 900; x < 1100; x += 3) {
-				for (float y = 900; y < 1100; y += 3) {
-					world.create<Plant>(foliage, Location {geoData->positionAt({-x, -y})});
-				}
-			}
+			// auto foliage = std::dynamic_pointer_cast<Foliage>(assets.at("Tree-01-1"));
+			// for (float x = 900; x < 1100; x += 3) {
+			// for (float y = 900; y < 1100; y += 3) {
+			// world.create<Plant>(foliage, Location {terrainMesh->positionAt(glm::vec2 {-x, -y})});
+			//}
+			//}
 		}
 
 		auto t_start = std::chrono::high_resolution_clock::now();
diff --git a/game/geoData.cpp b/game/geoData.cpp
index 34a1030..d32bf8c 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -1,214 +1,238 @@
 #include "geoData.h"
-#include "gfx/image.h"
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <cstddef>
+#include <fstream>
 #include <glm/gtx/intersect.hpp>
-#include <initializer_list>
-#include <limits>
 #include <maths.h>
-#include <random>
-#include <ray.h>
-#include <stb/stb_image.h>
-#include <stdexcept>
-#include <util.h>
-
-GeoData::GeoData(Limits l, float s) :
-	limit {std::move(l)}, size {(limit.second - limit.first) + 1}, scale {s}, nodes {[this]() {
-		return (static_cast<std::size_t>(size.x * size.y));
-	}()}
-{
-}
 
-void
-GeoData::generateRandom()
+GeoData
+GeoData::loadFromAsciiGrid(const std::filesystem::path & input)
 {
-	// We acknowledge this is terrible :)
-
-	// Add hills
-	std::mt19937 gen(std::random_device {}());
-	std::uniform_int_distribution<> rxpos(limit.first.x + 2, limit.second.x - 2),
-			rypos(limit.first.y + 2, limit.second.y - 2);
-	std::uniform_int_distribution<> rsize(10, 30);
-	std::uniform_real_distribution<float> rheight(1, 3);
-	for (int h = 0; h < 500;) {
-		const glm::ivec2 hpos {rxpos(gen), rypos(gen)};
-		const glm::ivec2 hsize {rsize(gen), rsize(gen)};
-		if (const auto lim1 = hpos - hsize; lim1.x > limit.first.x && lim1.y > limit.first.y) {
-			if (const auto lim2 = hpos + hsize; lim2.x < limit.second.x && lim2.y < limit.second.y) {
-				const auto height = rheight(gen);
-				const glm::ivec2 hsizesqrd {hsize.x * hsize.x, hsize.y * hsize.y};
-				for (auto y = lim1.y; y < lim2.y; y += 1) {
-					for (auto x = lim1.x; x < lim2.x; x += 1) {
-						const auto dist {hpos - glm::ivec2 {x, y}};
-						const glm::ivec2 distsqrd {dist.x * dist.x, dist.y * dist.y};
-						const auto out {ratio(sq(x - hpos.x), sq(hsize.x)) + ratio(sq(y - hpos.y), sq(hsize.y))};
-						if (out <= 1.0F) {
-							auto & node {nodes[at({x, y})]};
-							const auto m {1.F / (7.F * out - 8.F) + 1.F};
-							node.height += height * m;
-						}
-					}
-				}
-				h += 1;
-			}
+	size_t ncols = 0, nrows = 0, xllcorner = 0, yllcorner = 0, cellsize = 0;
+	std::map<std::string_view, size_t *> properties {
+			{"ncols", &ncols},
+			{"nrows", &nrows},
+			{"xllcorner", &xllcorner},
+			{"yllcorner", &yllcorner},
+			{"cellsize", &cellsize},
+	};
+	std::ifstream f {input};
+	while (!properties.empty()) {
+		std::string property;
+		f >> property;
+		f >> *properties.at(property);
+		properties.erase(property);
+	}
+	std::vector<VertexHandle> vertices;
+	vertices.reserve(ncols * nrows);
+	GeoData mesh;
+	mesh.lowerExtent = {xllcorner, yllcorner, std::numeric_limits<float>::max()};
+	mesh.upperExtent
+			= {xllcorner + (cellsize * ncols), yllcorner + (cellsize * nrows), std::numeric_limits<float>::min()};
+	for (size_t row = 0; row < nrows; ++row) {
+		for (size_t col = 0; col < ncols; ++col) {
+			float height = 0;
+			f >> height;
+			mesh.upperExtent.z = std::max(mesh.upperExtent.z, height);
+			mesh.lowerExtent.z = std::min(mesh.lowerExtent.z, height);
+			vertices.push_back(mesh.add_vertex({xllcorner + (col * cellsize), yllcorner + (row * cellsize), height}));
 		}
 	}
-}
+	if (!f.good()) {
+		throw std::runtime_error("Couldn't read terrain file");
+	}
+	for (size_t row = 1; row < nrows; ++row) {
+		for (size_t col = 1; col < ncols; ++col) {
+			mesh.add_face({
+					vertices[ncols * (row - 1) + (col - 1)],
+					vertices[ncols * (row - 0) + (col - 0)],
+					vertices[ncols * (row - 0) + (col - 1)],
+			});
+			mesh.add_face({
+					vertices[ncols * (row - 1) + (col - 1)],
+					vertices[ncols * (row - 1) + (col - 0)],
+					vertices[ncols * (row - 0) + (col - 0)],
+			});
+		}
+	}
+	mesh.update_face_normals();
+	mesh.update_vertex_normals();
 
-void
-GeoData::loadFromImages(const std::filesystem::path & fileName, float scale_)
-{
-	const Image map {fileName.c_str(), STBI_grey};
-	size = {map.width, map.height};
-	limit = {{0, 0}, size - glm::uvec2 {1, 1}};
-	const auto points {size.x * size.y};
-	scale = scale_;
-	nodes.resize(points);
-
-	std::transform(map.data.data(), map.data.data() + points, nodes.begin(), [](auto d) {
-		return Node {(d * 0.1F) - 1.5F};
-	});
-}
+	return mesh;
+};
 
-GeoData::Quad
-GeoData::quad(glm::vec2 wcoord) const
+GeoData
+GeoData::createFlat(glm::vec2 lower, glm::vec2 upper, float h)
 {
-	constexpr static const std::array<glm::vec2, 4> corners {{{0, 0}, {0, 1}, {1, 0}, {1, 1}}};
-	return transform_array(transform_array(corners,
-								   [coord = (wcoord / scale)](const auto c) {
-									   return glm::vec2 {std::floor(coord.x), std::floor(coord.y)} + c;
-								   }),
-			[this](const auto c) {
-				return (c * scale) || nodes[at(c)].height;
-			});
-}
+	GeoData mesh;
 
-glm::vec3
-GeoData::positionAt(const glm::vec2 wcoord) const
-{
-	const auto point {quad(wcoord)};
-	const glm::vec2 frac = (wcoord - !point.front()) / scale;
-	auto edge = [&point, &frac](auto offset) {
-		return point[offset].z + ((point[offset + 2].z - point[offset].z) * frac.x);
-	};
-	const auto heightFloor = edge(0U), heightCeil = edge(1U),
-			   heightMid = heightFloor + ((heightCeil - heightFloor) * frac.y);
+	mesh.lowerExtent = lower ^ h;
+	mesh.upperExtent = upper ^ h;
+
+	const auto ll = mesh.add_vertex({lower.x, lower.y, h}), lu = mesh.add_vertex({lower.x, upper.y, h}),
+			   ul = mesh.add_vertex({upper.x, lower.y, h}), uu = mesh.add_vertex({upper.x, upper.y, h});
+
+	mesh.add_face(ll, uu, lu);
+	mesh.add_face(ll, ul, uu);
 
-	return wcoord || heightMid;
+	mesh.update_face_normals();
+	mesh.update_vertex_normals();
+
+	return mesh;
 }
 
-GeoData::RayTracer::RayTracer(glm::vec2 p0, glm::vec2 p1) : RayTracer {p0, p1, glm::abs(p1)} { }
-GeoData::RayTracer::RayTracer(glm::vec2 p0, glm::vec2 p1, glm::vec2 d) :
-	RayTracer {p0, d, byAxis(p0, p1, d, 0), byAxis(p0, p1, d, 1)}
+OpenMesh::FaceHandle
+GeoData::findPoint(glm::vec2 p) const
 {
+	return findPoint(p, *faces_begin());
 }
 
-GeoData::RayTracer::RayTracer(
-		glm::vec2 p0, glm::vec2 d_, std::pair<float, float> xdata, std::pair<float, float> ydata) :
-	p {glm::floor(p0)},
-	d {d_}, error {xdata.second - ydata.second}, inc {xdata.first, ydata.first}
+GeoData::PointFace::PointFace(const glm::vec2 p, const GeoData * mesh) : PointFace {p, mesh, *mesh->faces_begin()} { }
+
+GeoData::PointFace::PointFace(const glm::vec2 p, const GeoData * mesh, FaceHandle start) :
+	PointFace {p, mesh->findPoint(p, start)}
 {
 }
 
-std::pair<float, float>
-GeoData::RayTracer::byAxis(glm::vec2 p0, glm::vec2 p1, glm::vec2 d, glm::length_t axis)
+GeoData::FaceHandle
+GeoData::PointFace::face(const GeoData * mesh, FaceHandle start) const
 {
-	using Limits = std::numeric_limits<typename glm::vec2::value_type>;
-	static_assert(Limits::has_infinity);
-	if (d[axis] == 0) {
-		return {0, Limits::infinity()};
-	}
-	else if (p1[axis] > 0) {
-		return {1, (std::floor(p0[axis]) + 1.F - p0[axis]) * d[1 - axis]};
+	if (_face.is_valid()) {
+		assert(mesh->triangleContainsPoint(point, _face));
+		return _face;
 	}
 	else {
-		return {-1, (p0[axis] - std::floor(p0[axis])) * d[1 - axis]};
+		return (_face = mesh->findPoint(point, start));
 	}
 }
 
-glm::vec2
-GeoData::RayTracer::next()
+GeoData::FaceHandle
+GeoData::PointFace::face(const GeoData * mesh) const
 {
-	const glm::vec2 cur {p};
+	return face(mesh, *mesh->faces_begin());
+}
+
+namespace {
+	[[nodiscard]] constexpr inline bool
+	pointLeftOfLine(const glm::vec2 p, const glm::vec2 e1, const glm::vec2 e2)
+	{
+		return (e2.x - e1.x) * (p.y - e1.y) > (e2.y - e1.y) * (p.x - e1.x);
+	}
 
-	static constexpr const glm::vec2 m {1, -1};
-	const int axis = (error > 0) ? 1 : 0;
-	p[axis] += inc[axis];
-	error += d[1 - axis] * m[axis];
+	static_assert(pointLeftOfLine({1, 2}, {1, 1}, {2, 2}));
+	static_assert(pointLeftOfLine({2, 1}, {2, 2}, {1, 1}));
+	static_assert(pointLeftOfLine({2, 2}, {1, 2}, {2, 1}));
+	static_assert(pointLeftOfLine({1, 1}, {2, 1}, {1, 2}));
 
-	return cur;
+	[[nodiscard]] constexpr inline bool
+	linesCross(const glm::vec2 a1, const glm::vec2 a2, const glm::vec2 b1, const glm::vec2 b2)
+	{
+		return pointLeftOfLine(a2, b1, b2) && pointLeftOfLine(a1, b2, b1) && pointLeftOfLine(b1, a1, a2)
+				&& pointLeftOfLine(b2, a2, a1);
+	}
+
+	static_assert(linesCross({1, 1}, {2, 2}, {1, 2}, {2, 1}));
 }
 
-std::optional<glm::vec3>
-GeoData::intersectRay(const Ray & ray) const
+OpenMesh::FaceHandle
+GeoData::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const
 {
-	if (glm::length(!ray.direction) <= 0) {
-		return {};
-	}
-	RayTracer rt {ray.start / scale, ray.direction};
-	while (true) {
-		const auto n {rt.next() * scale};
-		try {
-			const auto point = quad(n);
-			for (auto offset : {0U, 1U}) {
-				glm::vec2 bary;
-				float distance;
-				if (glm::intersectRayTriangle(ray.start, ray.direction, point[offset], point[offset + 1],
-							point[offset + 2], bary, distance)) {
-					return point[offset] + ((point[offset + 1] - point[offset]) * bary[0])
-							+ ((point[offset + 2] - point[offset]) * bary[1]);
+	ConstFaceVertexIter vertices;
+	while (f.is_valid() && !triangleContainsPoint(p, vertices = cfv_iter(f))) {
+		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
+			f = opposite_face_handle(*next);
+			if (f.is_valid()) {
+				const auto e1 = point(to_vertex_handle(*next));
+				const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next)));
+				if (pointLeftOfLine(p, e1, e2)) {
+					break;
 				}
 			}
-		}
-		catch (std::range_error &) {
-			const auto rel = n / !ray.direction;
-			if (rel.x > 0 && rel.y > 0) {
-				return {};
-			}
+			f.reset();
 		}
 	}
+	return f;
+}
 
-	return {};
+glm::vec3
+GeoData::positionAt(const PointFace & p) const
+{
+	glm::vec3 out {};
+	Triangle<3> t {this, fv_range(p.face(this))};
+	glm::intersectLineTriangle(p.point ^ 0.F, up, t[0], t[1], t[2], out);
+	return p.point ^ out[0];
 }
 
-unsigned int
-GeoData::at(glm::ivec2 coord) const
+[[nodiscard]] std::optional<glm::vec3>
+GeoData::intersectRay(const Ray & ray) const
 {
-	if (coord.x < limit.first.x || coord.x > limit.second.x || coord.y < limit.first.y || coord.y > limit.second.y) {
-		throw std::range_error {"Coordinates outside GeoData limits"};
-	}
-	const glm::uvec2 offset = coord - limit.first;
-	return offset.x + (offset.y * size.x);
+	return intersectRay(ray, findPoint(ray.start));
 }
 
-unsigned int
-GeoData::at(int x, int y) const
+[[nodiscard]] std::optional<glm::vec3>
+GeoData::intersectRay(const Ray & ray, FaceHandle face) const
 {
-	return at({x, y});
+	std::optional<glm::vec3> out;
+	walkUntil(PointFace {ray.start, face}, ray.start + (ray.direction * 10000.F), [&out, &ray, this](FaceHandle face) {
+		glm::vec2 bari {};
+		float dist {};
+		Triangle<3> t {this, fv_range(face)};
+		if (glm::intersectRayTriangle(ray.start, ray.direction, t[0], t[1], t[2], bari, dist)) {
+			out = t * bari;
+			return true;
+		}
+		return false;
+	});
+	return out;
 }
 
-GeoData::Limits
-GeoData::getLimit() const
+void
+GeoData::walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const
 {
-	return limit;
+	walkUntil(from, to, [&op](const auto & fh) {
+		op(fh);
+		return false;
+	});
 }
 
-float
-GeoData::getScale() const
+void
+GeoData::walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const
+{
+	assert(from.face(this).is_valid()); // TODO replace with a boundary search
+	auto f = from.face(this);
+	FaceHandle previousFace;
+	while (f.is_valid() && !op(f)) {
+		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
+			f = opposite_face_handle(*next);
+			if (f.is_valid() && f != previousFace) {
+				const auto e1 = point(to_vertex_handle(*next));
+				const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next)));
+				if (linesCross(from.point, to, e1, e2)) {
+					previousFace = f;
+					break;
+				}
+			}
+			f.reset();
+		}
+	}
+}
+
+bool
+GeoData::triangleContainsPoint(const glm::vec2 p, const glm::vec2 a, const glm::vec2 b, const glm::vec2 c)
 {
-	return scale;
+	const auto det = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+
+	return det * ((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x)) >= 0
+			&& det * ((c.x - b.x) * (p.y - b.y) - (c.y - b.y) * (p.x - b.x)) >= 0
+			&& det * ((a.x - c.x) * (p.y - c.y) - (a.y - c.y) * (p.x - c.x)) >= 0;
 }
 
-glm::uvec2
-GeoData::getSize() const
+bool
+GeoData::triangleContainsPoint(const glm::vec2 p, FaceHandle face) const
 {
-	return size;
+	return triangleContainsPoint(p, cfv_iter(face));
 }
 
-std::span<const GeoData::Node>
-GeoData::getNodes() const
+bool
+GeoData::triangleContainsPoint(const glm::vec2 p, ConstFaceVertexIter vertices) const
 {
-	return nodes;
+	return triangleContainsPoint(p, point(*vertices++), point(*vertices++), point(*vertices++));
 }
diff --git a/game/geoData.h b/game/geoData.h
index f433a5c..3a4f98e 100644
--- a/game/geoData.h
+++ b/game/geoData.h
@@ -1,61 +1,94 @@
 #pragma once
 
-#include <array>
+#include "collections.h" // IWYU pragma: keep IterableCollection
+#include "ray.h"
+#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>
 #include <filesystem>
-#include <glm/glm.hpp>
+#include <glm/vec2.hpp>
 #include <optional>
-#include <span>
-#include <utility>
-#include <vector>
+#include <thirdparty/openmesh/glmcompat.h>
 
-class Ray;
+struct GeoDataTraits : public OpenMesh::DefaultTraits {
+	FaceAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
+	EdgeAttributes(OpenMesh::Attributes::Status);
+	VertexAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
+	HalfedgeAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
+	using Point = glm::vec3;
+	using Normal = glm::vec3;
+};
+
+class GeoData : public OpenMesh::TriMesh_ArrayKernelT<GeoDataTraits> {
+private:
+	GeoData() = default;
 
-class GeoData {
 public:
-	struct Node {
-		float height {-1.5F};
-	};
-	using Quad = std::array<glm::vec3, 4>;
+	static GeoData loadFromAsciiGrid(const std::filesystem::path &);
+	static GeoData createFlat(glm::vec2 lower, glm::vec2, float h);
 
-	using Limits = std::pair<glm::ivec2, glm::ivec2>;
+	struct PointFace {
+		// NOLINTNEXTLINE(hicpp-explicit-conversions)
+		PointFace(const glm::vec2 p) : point {p} { }
 
-	explicit GeoData(Limits limit, float scale = 10.F);
+		PointFace(const glm::vec2 p, FaceHandle face) : point {p}, _face {face} { }
 
-	void generateRandom();
-	void loadFromImages(const std::filesystem::path &, float scale);
+		PointFace(const glm::vec2 p, const GeoData *);
+		PointFace(const glm::vec2 p, const GeoData *, FaceHandle start);
 
-	[[nodiscard]] glm::vec3 positionAt(glm::vec2) const;
-	[[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &) const;
+		const glm::vec2 point;
+		[[nodiscard]] FaceHandle face(const GeoData *) const;
+		[[nodiscard]] FaceHandle face(const GeoData *, FaceHandle start) const;
 
-	[[nodiscard]] unsigned int at(glm::ivec2) const;
-	[[nodiscard]] unsigned int at(int x, int y) const;
-	[[nodiscard]] Quad quad(glm::vec2) const;
+		[[nodiscard]] bool
+		isLocated() const
+		{
+			return _face.is_valid();
+		}
 
-	[[nodiscard]] Limits getLimit() const;
-	[[nodiscard]] glm::uvec2 getSize() const;
-	[[nodiscard]] float getScale() const;
-	[[nodiscard]] std::span<const Node> getNodes() const;
+	private:
+		mutable FaceHandle _face {};
+	};
 
-	class RayTracer {
-	public:
-		RayTracer(glm::vec2 p0, glm::vec2 p1);
+	template<glm::length_t Dim> struct Triangle : public glm::vec<3, glm::vec<Dim, glm::vec2::value_type>> {
+		using base = glm::vec<3, glm::vec<Dim, glm::vec2::value_type>>;
+		using base::base;
 
-		glm::vec2 next();
+		template<IterableCollection Range> Triangle(const GeoData * m, Range range)
+		{
+			assert(std::distance(range.begin(), range.end()) == 3);
+			std::transform(range.begin(), range.end(), &base::operator[](0), [m](auto vh) {
+				return m->point(vh);
+			});
+		}
 
-	private:
-		RayTracer(glm::vec2 p0, glm::vec2 p1, glm::vec2 d);
-		RayTracer(glm::vec2 p0, glm::vec2 d, std::pair<float, float>, std::pair<float, float>);
-		static std::pair<float, float> byAxis(glm::vec2 p0, glm::vec2 p1, glm::vec2 d, glm::length_t);
-
-		glm::vec2 p;
-		const glm::vec2 d;
-		float error;
-		glm::vec2 inc;
+		glm::vec<Dim, glm::vec2::value_type>
+		operator*(glm::vec2 bari) const
+		{
+			const auto & t {*this};
+			return t[0] + ((t[1] - t[0]) * bari.x) + ((t[2] - t[1]) * bari.y);
+		}
 	};
 
+	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
+	[[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const;
+
+	[[nodiscard]] glm::vec3 positionAt(const PointFace &) const;
+	[[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &) const;
+	[[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &, FaceHandle start) const;
+
+	void walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const;
+	void walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const;
+
+	[[nodiscard]] auto
+	getExtents() const
+	{
+		return std::tie(lowerExtent, upperExtent);
+	}
+
 protected:
-	Limits limit {}; // Base grid limits first(x,y) -> second(x,y)
-	glm::uvec2 size {};
-	float scale {1};
-	std::vector<Node> nodes;
+	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
+	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
+	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, ConstFaceVertexIter) const;
+
+private:
+	glm::vec3 lowerExtent {}, upperExtent {};
 };
diff --git a/game/terrain.cpp b/game/terrain.cpp
index f3bec1e..5bb8abd 100644
--- a/game/terrain.cpp
+++ b/game/terrain.cpp
@@ -2,7 +2,6 @@
 #include "game/geoData.h"
 #include "gfx/models/texture.h"
 #include <algorithm>
-#include <array>
 #include <cache.h>
 #include <cstddef>
 #include <filesystem>
@@ -18,8 +17,8 @@
 #include <utility>
 #include <vector>
 
-Terrain::Terrain(std::shared_ptr<GeoData> gd) :
-	geoData {std::move(gd)}, grass {Texture::cachedTexture.get("grass.png")},
+Terrain::Terrain(std::shared_ptr<GeoData> tm) :
+	geoData {std::move(tm)}, grass {Texture::cachedTexture.get("grass.png")},
 	water {Texture::cachedTexture.get("water.png")}
 {
 	generateMeshes();
@@ -29,51 +28,23 @@ void
 Terrain::generateMeshes()
 {
 	std::vector<unsigned int> indices;
-	const auto isize = geoData->getSize() - glm::uvec2 {1, 1};
-	indices.reserve(static_cast<std::size_t>(isize.x * isize.y) * 6);
-
-	const auto limit = geoData->getLimit();
-	//  Indices
-	constexpr std::array<glm::ivec2, 6> indices_offsets {{
-			{0, 0},
-			{1, 0},
-			{1, 1},
-			{0, 0},
-			{1, 1},
-			{0, 1},
-	}};
-	for (auto y = limit.first.y; y < limit.second.y; y += 1) {
-		for (auto x = limit.first.x; x < limit.second.x; x += 1) {
-			std::transform(indices_offsets.begin(), indices_offsets.end(), std::back_inserter(indices),
-					[this, x, y](const auto off) {
-						return geoData->at(x + off.x, y + off.y);
-					});
-		}
-	}
-
-	const auto nodes = geoData->getNodes();
-	const auto scale = geoData->getScale();
+	indices.reserve(geoData->n_faces() * 3);
 	std::vector<Vertex> vertices;
-	vertices.reserve(nodes.size());
-	// Positions
-	for (auto y = limit.first.y; y <= limit.second.y; y += 1) {
-		for (auto x = limit.first.x; x <= limit.second.x; x += 1) {
-			const glm::vec2 xy {x, y};
-			vertices.emplace_back((xy * scale) ^ nodes[geoData->at(x, y)].height, xy, ::up);
-		}
-	}
-	// Normals
-	const glm::uvec2 size = geoData->getSize();
-	for (auto y = limit.first.y + 1; y < limit.second.y; y += 1) {
-		for (auto x = limit.first.x + 1; x < limit.second.x; x += 1) {
-			const auto n {geoData->at(x, y)};
-			const auto a = vertices[n - 1].pos;
-			const auto b = vertices[n - size.x].pos;
-			const auto c = vertices[n + 1].pos;
-			const auto d = vertices[n + size.x].pos;
-			vertices[n].normal = -glm::normalize(glm::cross(b - d, a - c));
-		}
-	}
+	vertices.reserve(geoData->n_vertices());
+	std::map<GeoData::VertexHandle, size_t> vertexIndex;
+	std::transform(geoData->vertices_begin(), geoData->vertices_end(), std::back_inserter(vertices),
+			[this, &vertexIndex](const GeoData::VertexHandle v) {
+				vertexIndex.emplace(v, vertexIndex.size());
+				const glm::vec3 p = geoData->point(v);
+				return Vertex {p, p / 10.F, geoData->normal(v)};
+			});
+	std::for_each(
+			geoData->faces_begin(), geoData->faces_end(), [this, &vertexIndex, &indices](const GeoData::FaceHandle f) {
+				std::transform(geoData->fv_begin(f), geoData->fv_end(f), std::back_inserter(indices),
+						[&vertexIndex](const GeoData::VertexHandle v) {
+							return vertexIndex[v];
+						});
+			});
 	meshes.create<Mesh>(vertices, indices);
 }
 
diff --git a/game/terrain2.cpp b/game/terrain2.cpp
deleted file mode 100644
index 0e8b78e..0000000
--- a/game/terrain2.cpp
+++ /dev/null
@@ -1,221 +0,0 @@
-#include "terrain2.h"
-#include <fstream>
-#include <glm/gtx/intersect.hpp>
-#include <maths.h>
-
-TerrainMesh
-TerrainMesh::loadFromAsciiGrid(const std::filesystem::path & input)
-{
-	size_t ncols = 0, nrows = 0, xllcorner = 0, yllcorner = 0, cellsize = 0;
-	std::map<std::string_view, size_t *> properties {
-			{"ncols", &ncols},
-			{"nrows", &nrows},
-			{"xllcorner", &xllcorner},
-			{"yllcorner", &yllcorner},
-			{"cellsize", &cellsize},
-	};
-	std::ifstream f {input};
-	while (!properties.empty()) {
-		std::string property;
-		f >> property;
-		f >> *properties.at(property);
-		properties.erase(property);
-	}
-	std::vector<VertexHandle> vertices;
-	vertices.reserve(ncols * nrows);
-	TerrainMesh mesh;
-	mesh.lowerExtent = {xllcorner, yllcorner, std::numeric_limits<float>::max()};
-	mesh.upperExtent
-			= {xllcorner + (cellsize * ncols), yllcorner + (cellsize * nrows), std::numeric_limits<float>::min()};
-	for (size_t row = 0; row < nrows; ++row) {
-		for (size_t col = 0; col < ncols; ++col) {
-			float height = 0;
-			f >> height;
-			mesh.upperExtent.z = std::max(mesh.upperExtent.z, height);
-			mesh.lowerExtent.z = std::min(mesh.lowerExtent.z, height);
-			vertices.push_back(mesh.add_vertex({xllcorner + (col * cellsize), yllcorner + (row * cellsize), height}));
-		}
-	}
-	if (!f.good()) {
-		throw std::runtime_error("Couldn't read terrain file");
-	}
-	for (size_t row = 1; row < nrows; ++row) {
-		for (size_t col = 1; col < ncols; ++col) {
-			mesh.add_face({
-					vertices[ncols * (row - 1) + (col - 1)],
-					vertices[ncols * (row - 0) + (col - 0)],
-					vertices[ncols * (row - 0) + (col - 1)],
-			});
-			mesh.add_face({
-					vertices[ncols * (row - 1) + (col - 1)],
-					vertices[ncols * (row - 1) + (col - 0)],
-					vertices[ncols * (row - 0) + (col - 0)],
-			});
-		}
-	}
-	mesh.update_face_normals();
-	mesh.update_vertex_normals();
-
-	return mesh;
-};
-
-OpenMesh::FaceHandle
-TerrainMesh::findPoint(glm::vec2 p) const
-{
-	return findPoint(p, *faces_begin());
-}
-
-TerrainMesh::PointFace::PointFace(const glm::vec2 p, const TerrainMesh * mesh) :
-	PointFace {p, mesh, *mesh->faces_begin()}
-{
-}
-
-TerrainMesh::PointFace::PointFace(const glm::vec2 p, const TerrainMesh * mesh, FaceHandle start) :
-	PointFace {p, mesh->findPoint(p, start)}
-{
-}
-
-TerrainMesh::FaceHandle
-TerrainMesh::PointFace::face(const TerrainMesh * mesh, FaceHandle start) const
-{
-	if (_face.is_valid()) {
-		assert(mesh->triangleContainsPoint(point, _face));
-		return _face;
-	}
-	else {
-		return (_face = mesh->findPoint(point, start));
-	}
-}
-
-TerrainMesh::FaceHandle
-TerrainMesh::PointFace::face(const TerrainMesh * mesh) const
-{
-	return face(mesh, *mesh->faces_begin());
-}
-
-namespace {
-	[[nodiscard]] constexpr inline bool
-	pointLeftOfLine(const glm::vec2 p, const glm::vec2 e1, const glm::vec2 e2)
-	{
-		return (e2.x - e1.x) * (p.y - e1.y) > (e2.y - e1.y) * (p.x - e1.x);
-	}
-
-	static_assert(pointLeftOfLine({1, 2}, {1, 1}, {2, 2}));
-	static_assert(pointLeftOfLine({2, 1}, {2, 2}, {1, 1}));
-	static_assert(pointLeftOfLine({2, 2}, {1, 2}, {2, 1}));
-	static_assert(pointLeftOfLine({1, 1}, {2, 1}, {1, 2}));
-
-	[[nodiscard]] constexpr inline bool
-	linesCross(const glm::vec2 a1, const glm::vec2 a2, const glm::vec2 b1, const glm::vec2 b2)
-	{
-		return pointLeftOfLine(a2, b1, b2) && pointLeftOfLine(a1, b2, b1) && pointLeftOfLine(b1, a1, a2)
-				&& pointLeftOfLine(b2, a2, a1);
-	}
-
-	static_assert(linesCross({1, 1}, {2, 2}, {1, 2}, {2, 1}));
-}
-
-OpenMesh::FaceHandle
-TerrainMesh::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const
-{
-	ConstFaceVertexIter vertices;
-	while (f.is_valid() && !triangleContainsPoint(p, vertices = cfv_iter(f))) {
-		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
-			f = opposite_face_handle(*next);
-			if (f.is_valid()) {
-				const auto e1 = point(to_vertex_handle(*next));
-				const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next)));
-				if (pointLeftOfLine(p, e1, e2)) {
-					break;
-				}
-			}
-			f.reset();
-		}
-	}
-	return f;
-}
-
-glm::vec3
-TerrainMesh::positionAt(const PointFace & p) const
-{
-	glm::vec3 out {};
-	Triangle<3> t {this, fv_range(p.face(this))};
-	glm::intersectLineTriangle(p.point ^ 0.F, up, t[0], t[1], t[2], out);
-	return p.point ^ out[0];
-}
-
-[[nodiscard]] std::optional<glm::vec3>
-TerrainMesh::intersectRay(const Ray & ray) const
-{
-	return intersectRay(ray, findPoint(ray.start));
-}
-
-[[nodiscard]] std::optional<glm::vec3>
-TerrainMesh::intersectRay(const Ray & ray, FaceHandle face) const
-{
-	std::optional<glm::vec3> out;
-	walkUntil(PointFace {ray.start, face}, ray.start + (ray.direction * 10000.F), [&out, &ray, this](FaceHandle face) {
-		glm::vec2 bari {};
-		float dist {};
-		Triangle<3> t {this, fv_range(face)};
-		if (glm::intersectRayTriangle(ray.start, ray.direction, t[0], t[1], t[2], bari, dist)) {
-			out = t * bari;
-			return true;
-		}
-		return false;
-	});
-	return out;
-}
-
-void
-TerrainMesh::walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const
-{
-	walkUntil(from, to, [&op](const auto & fh) {
-		op(fh);
-		return false;
-	});
-}
-
-void
-TerrainMesh::walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const
-{
-	assert(from.face(this).is_valid()); // TODO replace with a boundary search
-	auto f = from.face(this);
-	FaceHandle previousFace;
-	while (f.is_valid() && !op(f)) {
-		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
-			f = opposite_face_handle(*next);
-			if (f.is_valid() && f != previousFace) {
-				const auto e1 = point(to_vertex_handle(*next));
-				const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next)));
-				if (linesCross(from.point, to, e1, e2)) {
-					previousFace = f;
-					break;
-				}
-			}
-			f.reset();
-		}
-	}
-}
-
-bool
-TerrainMesh::triangleContainsPoint(const glm::vec2 p, const glm::vec2 a, const glm::vec2 b, const glm::vec2 c)
-{
-	const auto det = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
-
-	return det * ((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x)) >= 0
-			&& det * ((c.x - b.x) * (p.y - b.y) - (c.y - b.y) * (p.x - b.x)) >= 0
-			&& det * ((a.x - c.x) * (p.y - c.y) - (a.y - c.y) * (p.x - c.x)) >= 0;
-}
-
-bool
-TerrainMesh::triangleContainsPoint(const glm::vec2 p, FaceHandle face) const
-{
-	return triangleContainsPoint(p, cfv_iter(face));
-}
-
-bool
-TerrainMesh::triangleContainsPoint(const glm::vec2 p, ConstFaceVertexIter vertices) const
-{
-	return triangleContainsPoint(p, point(*vertices++), point(*vertices++), point(*vertices++));
-}
diff --git a/game/terrain2.h b/game/terrain2.h
deleted file mode 100644
index eda56d0..0000000
--- a/game/terrain2.h
+++ /dev/null
@@ -1,93 +0,0 @@
-#pragma once
-
-#include "collections.h" // IWYU pragma: keep IterableCollection
-#include "ray.h"
-#include <OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh>
-#include <filesystem>
-#include <glm/vec2.hpp>
-#include <optional>
-#include <thirdparty/openmesh/glmcompat.h>
-
-struct TerrainTraits : public OpenMesh::DefaultTraits {
-	FaceAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
-	EdgeAttributes(OpenMesh::Attributes::Status);
-	VertexAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
-	HalfedgeAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
-	using Point = glm::vec3;
-	using Normal = glm::vec3;
-};
-
-class TerrainMesh : public OpenMesh::TriMesh_ArrayKernelT<TerrainTraits> {
-private:
-	TerrainMesh() = default;
-
-public:
-	static TerrainMesh loadFromAsciiGrid(const std::filesystem::path &);
-
-	struct PointFace {
-		// NOLINTNEXTLINE(hicpp-explicit-conversions)
-		PointFace(const glm::vec2 p) : point {p} { }
-
-		PointFace(const glm::vec2 p, FaceHandle face) : point {p}, _face {face} { }
-
-		PointFace(const glm::vec2 p, const TerrainMesh *);
-		PointFace(const glm::vec2 p, const TerrainMesh *, FaceHandle start);
-
-		const glm::vec2 point;
-		[[nodiscard]] FaceHandle face(const TerrainMesh *) const;
-		[[nodiscard]] FaceHandle face(const TerrainMesh *, FaceHandle start) const;
-
-		[[nodiscard]] bool
-		isLocated() const
-		{
-			return _face.is_valid();
-		}
-
-	private:
-		mutable FaceHandle _face {};
-	};
-
-	template<glm::length_t Dim> struct Triangle : public glm::vec<3, glm::vec<Dim, glm::vec2::value_type>> {
-		using base = glm::vec<3, glm::vec<Dim, glm::vec2::value_type>>;
-		using base::base;
-
-		template<IterableCollection Range> Triangle(const TerrainMesh * m, Range range)
-		{
-			assert(std::distance(range.begin(), range.end()) == 3);
-			std::transform(range.begin(), range.end(), &base::operator[](0), [m](auto vh) {
-				return m->point(vh);
-			});
-		}
-
-		glm::vec<Dim, glm::vec2::value_type>
-		operator*(glm::vec2 bari) const
-		{
-			const auto & t {*this};
-			return t[0] + ((t[1] - t[0]) * bari.x) + ((t[2] - t[1]) * bari.y);
-		}
-	};
-
-	[[nodiscard]] FaceHandle findPoint(glm::vec2) const;
-	[[nodiscard]] FaceHandle findPoint(glm::vec2, FaceHandle start) const;
-
-	[[nodiscard]] glm::vec3 positionAt(const PointFace &) const;
-	[[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &) const;
-	[[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &, FaceHandle start) const;
-
-	void walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const;
-	void walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const;
-
-	[[nodiscard]] auto
-	getExtents() const
-	{
-		return std::tie(lowerExtent, upperExtent);
-	}
-
-protected:
-	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
-	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
-	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, ConstFaceVertexIter) const;
-
-private:
-	glm::vec3 lowerExtent {}, upperExtent {};
-};
diff --git a/test/Jamfile.jam b/test/Jamfile.jam
index d88a238..6f62056 100644
--- a/test/Jamfile.jam
+++ b/test/Jamfile.jam
@@ -46,7 +46,7 @@ lib test : [ glob *.cpp : test-*.cpp perf-*.cpp ] ;
 run test-collection.cpp ;
 run test-maths.cpp ;
 run test-lib.cpp ;
-run test-geo.cpp ;
+run test-geoData.cpp : -- : fixtures/height/SD19.asc : <library>test ;
 run test-network.cpp : : : <library>test ;
 run test-persistence.cpp : -- : [ sequence.insertion-sort [ glob-tree fixtures : *.json ] ] : <library>test ;
 run test-text.cpp : : : <library>test ;
@@ -55,13 +55,12 @@ run test-render.cpp : -- : test-assetFactory : <library>test ;
 run test-glContextBhvr.cpp ;
 run test-assetFactory.cpp : -- : [ sequence.insertion-sort [ glob-tree $(res) : *.* ] fixtures/rgb.txt test-instancing ] : <library>test ;
 run perf-assetFactory.cpp : -- : test-assetFactory : <library>benchmark <library>test ;
+run perf-geoData.cpp : : : <library>test <library>benchmark ;
 run perf-persistence.cpp : -- : test-persistence : <library>benchmark <library>test ;
 run test-worker.cpp ;
 run test-instancing.cpp : : : <library>test ;
 run test-glContainer.cpp : : : <library>test ;
 run test-pack.cpp : : : <library>test ;
-run test-terrain.cpp : -- : fixtures/height/SD19.asc : <library>test <library>..//OpenMeshCore ;
-run perf-terrain.cpp : : : <library>test <library>..//OpenMeshCore <library>benchmark ;
 compile test-static-enumDetails.cpp ;
 compile test-static-stream_support.cpp ;
 explicit perf-assetFactory ;
diff --git a/test/perf-geoData.cpp b/test/perf-geoData.cpp
new file mode 100644
index 0000000..e1546c1
--- /dev/null
+++ b/test/perf-geoData.cpp
@@ -0,0 +1,18 @@
+#include <benchmark/benchmark.h>
+#include <game/geoData.h>
+
+namespace {
+	const GeoData tm {GeoData::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")};
+
+	void
+	terrain_findPoint(benchmark::State & state)
+	{
+		for (auto _ : state) {
+			benchmark::DoNotOptimize(tm.findPoint({315555, 495556}));
+		}
+	}
+}
+
+BENCHMARK(terrain_findPoint);
+
+BENCHMARK_MAIN();
diff --git a/test/perf-terrain.cpp b/test/perf-terrain.cpp
deleted file mode 100644
index e998f60..0000000
--- a/test/perf-terrain.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <benchmark/benchmark.h>
-#include <game/terrain2.h>
-
-namespace {
-	const TerrainMesh tm {FIXTURESDIR "height/SD19.asc"};
-
-	void
-	terrain_findPoint(benchmark::State & state)
-	{
-		for (auto _ : state) {
-			benchmark::DoNotOptimize(tm.findPoint({315555, 495556}));
-		}
-	}
-}
-
-BENCHMARK(terrain_findPoint);
-
-BENCHMARK_MAIN();
diff --git a/test/test-geo.cpp b/test/test-geo.cpp
deleted file mode 100644
index 9874fb7..0000000
--- a/test/test-geo.cpp
+++ /dev/null
@@ -1,225 +0,0 @@
-#define BOOST_TEST_MODULE test_geo
-
-#include "testHelpers.h"
-#include <boost/test/data/test_case.hpp>
-#include <boost/test/unit_test.hpp>
-#include <stream_support.h>
-
-#include <game/geoData.h>
-#include <lib/ray.h>
-
-struct TestGeoData : public GeoData {
-	TestGeoData() : GeoData {{{-10, -5}, {30, 40}}, 5.F} { }
-};
-
-namespace std {
-	std::ostream &
-	operator<<(std::ostream & s, const Ray & r)
-	{
-		return (s << r.start << "->" << r.direction);
-	}
-}
-
-BOOST_FIXTURE_TEST_SUITE(tgd, TestGeoData)
-
-BOOST_AUTO_TEST_CASE(initialize)
-{
-	BOOST_CHECK_EQUAL(limit.first, glm::ivec2(-10, -5));
-	BOOST_CHECK_EQUAL(limit.second, glm::ivec2(30, 40));
-	BOOST_CHECK_EQUAL(scale, 5.F);
-	BOOST_CHECK_EQUAL(size, glm::uvec2(41, 46));
-	BOOST_CHECK_EQUAL(nodes.size(), 1886);
-	BOOST_CHECK(std::all_of(nodes.begin(), nodes.end(), [](const auto & n) {
-		return n.height == -1.5F;
-	}));
-}
-
-BOOST_AUTO_TEST_CASE(coords)
-{
-	BOOST_CHECK_EQUAL(at(-10, -5), 0);
-	BOOST_CHECK_EQUAL(at(-9, -5), 1);
-	BOOST_CHECK_EQUAL(at(0, -5), 10);
-	BOOST_CHECK_EQUAL(at(30, -5), 40);
-	BOOST_CHECK_EQUAL(at(30, 40), 1885);
-}
-
-BOOST_AUTO_TEST_CASE(coords_bad)
-{
-	BOOST_CHECK_THROW(std::ignore = at(-11, -5), std::range_error);
-	BOOST_CHECK_THROW(std::ignore = at(-10, -6), std::range_error);
-	BOOST_CHECK_THROW(std::ignore = at(-11, -6), std::range_error);
-	BOOST_CHECK_THROW(std::ignore = at(31, 40), std::range_error);
-	BOOST_CHECK_THROW(std::ignore = at(30, 41), std::range_error);
-	BOOST_CHECK_THROW(std::ignore = at(31, 41), std::range_error);
-}
-
-BOOST_AUTO_TEST_CASE(gen_random)
-{
-	// Can only really its sanity
-	generateRandom();
-	// Some terrain above sea level
-	BOOST_CHECK(std::any_of(nodes.begin(), nodes.end(), [](const auto & n) {
-		return n.height > 0;
-	}));
-	// Still an island
-	for (int x = limit.first.x; x <= limit.second.x; x += 1) {
-		BOOST_CHECK_EQUAL(nodes[at(x, limit.first.y)].height, -1.5F);
-		BOOST_CHECK_EQUAL(nodes[at(x, limit.second.y)].height, -1.5F);
-	}
-	for (int y = limit.first.y; y <= limit.second.y; y += 1) {
-		BOOST_CHECK_EQUAL(nodes[at(limit.first.x, y)].height, -1.5F);
-		BOOST_CHECK_EQUAL(nodes[at(limit.second.x, y)].height, -1.5F);
-	}
-}
-
-BOOST_AUTO_TEST_CASE(load_uk_heightmap)
-{
-	loadFromImages(FIXTURESDIR "/height/V0txo.jpg", 100.F);
-	// Some terrain above sea level
-	BOOST_CHECK(std::any_of(nodes.begin(), nodes.end(), [](const auto & n) {
-		return n.height > 0;
-	}));
-}
-
-BOOST_AUTO_TEST_CASE(get_height_at)
-{
-	// at(x,y) is index based
-	nodes[at(0, 0)].height = 1;
-	nodes[at(1, 0)].height = 2;
-	nodes[at(0, 1)].height = 3;
-	nodes[at(1, 1)].height = 4;
-
-	// positionAt(x,y) is world based
-	// Corners
-	BOOST_CHECK_EQUAL(positionAt({0, 0}), glm::vec3(0, 0, 1));
-	BOOST_CHECK_EQUAL(positionAt({5, 0}), glm::vec3(5, 0, 2));
-	BOOST_CHECK_EQUAL(positionAt({0, 5}), glm::vec3(0, 5, 3));
-	BOOST_CHECK_EQUAL(positionAt({5, 5}), glm::vec3(5, 5, 4));
-
-	// Edge midpoints
-	BOOST_CHECK_EQUAL(positionAt({0, 2.5F}), glm::vec3(0, 2.5F, 2));
-	BOOST_CHECK_EQUAL(positionAt({5, 2.5F}), glm::vec3(5, 2.5F, 3));
-	BOOST_CHECK_EQUAL(positionAt({2.5F, 0}), glm::vec3(2.5F, 0, 1.5F));
-	BOOST_CHECK_EQUAL(positionAt({2.5F, 5}), glm::vec3(2.5F, 5, 3.5F));
-
-	// Centre
-	BOOST_CHECK_EQUAL(positionAt({2.5F, 2.5F}), glm::vec3(2.5F, 2.5F, 2.5F));
-}
-
-using TestRayTracerData = std::tuple<glm::vec2, glm::vec2, glm::vec2::value_type, std::vector<glm::vec2>>;
-BOOST_TEST_DECORATOR(*boost::unit_test::timeout(1))
-
-BOOST_DATA_TEST_CASE(raytracer,
-		boost::unit_test::data::make<TestRayTracerData>({
-				{{1, 2}, {4, 5}, 4,
-						{
-								{0, 0},
-								{0, 4},
-								{4, 4},
-								{4, 8},
-								{8, 8},
-								{8, 12},
-								{12, 12},
-								{12, 16},
-								{12, 20},
-								{16, 20},
-						}},
-				{{-1, -1}, {-4, -5}, 5,
-						{
-								{-5, -5},
-								{-5, -10},
-								{-10, -10},
-								{-10, -15},
-								{-15, -15},
-								{-15, -20},
-								{-20, -20},
-								{-20, -25},
-						}},
-		}),
-		start, dir, scale, points)
-{
-	GeoData::RayTracer rt {start / scale, glm::normalize(dir)};
-	for (const auto & point : points) {
-		BOOST_CHECK_CLOSE_VEC(point, rt.next() * scale);
-	}
-}
-
-using TestRayData = std::tuple<glm::vec3, glm::vec3, glm::vec3>;
-BOOST_TEST_DECORATOR(*boost::unit_test::timeout(1))
-
-BOOST_DATA_TEST_CASE(intersect_ray,
-		boost::unit_test::data::make<TestRayData>({
-				{{-1, -1, 1.0}, {1, 1, 0}, {0, 0, 1}},
-				{{-1, -1, 2.5}, {1, 1, 0}, {2.5F, 2.5F, 2.5F}},
-				{{-20, -20, 2.5}, {1, 1, 0}, {2.5F, 2.5F, 2.5F}},
-				// outside the map looking in
-				{{-205, -205, 4}, {1, 1, 0}, {5, 5, 4}},
-				{{-205, 5, 4}, {1, 0, 0}, {5, 5, 4}},
-				{{-205, 215, 4}, {1, -1, 0}, {5, 5, 4}},
-				{{215, -205, 4}, {-1, 1, 0}, {5, 5, 4}},
-				{{215, 5, 4}, {-1, 0, 0}, {5, 5, 4}},
-				{{215, 215, 4}, {-1, -1, 0}, {5, 5, 4}},
-				{{5, 215, 4}, {0, -1, 0}, {5, 5, 4}},
-				{{5, -205, 4}, {0, 1, 0}, {5, 5, 4}},
-		}),
-		start, dir, pos)
-{
-	// at(x,y) is index based
-	nodes[at(0, 0)].height = 1;
-	nodes[at(1, 0)].height = 2;
-	nodes[at(0, 1)].height = 3;
-	nodes[at(1, 1)].height = 4;
-
-	const auto intersect = intersectRay({start, glm::normalize(dir)});
-
-	BOOST_CHECK_IF(has_intersect, intersect) {
-		BOOST_CHECK_CLOSE_VEC(*intersect, pos);
-	}
-}
-
-auto xs = boost::unit_test::data::xrange(-20.F, 0.F, 0.6F), ys = boost::unit_test::data::xrange(-20.F, 0.F, 0.7F);
-auto targetsx = boost::unit_test::data::xrange(0.2F, 4.9F, 1.3F),
-	 targetsy = boost::unit_test::data::xrange(0.3F, 4.9F, 1.3F);
-BOOST_TEST_DECORATOR(*boost::unit_test::timeout(1))
-
-BOOST_DATA_TEST_CASE(intersect_ray_many, xs * ys * targetsx * targetsy, x, y, targetx, targety)
-{
-	// at(x,y) is index based
-	nodes[at(0, 0)].height = 1;
-	nodes[at(1, 0)].height = 2;
-	nodes[at(0, 1)].height = 3;
-	nodes[at(1, 1)].height = 4;
-
-	const glm::vec3 start {x, y, 10};
-	const auto target {this->positionAt({targetx, targety})};
-	const Ray ray {start, glm::normalize(target - start)};
-
-	BOOST_TEST_CONTEXT(ray) {
-		const auto intersect = intersectRay(ray);
-
-		BOOST_CHECK_IF(has_intersect, intersect) {
-			BOOST_CHECK_CLOSE_VEC(*intersect, target);
-		}
-	}
-}
-
-BOOST_TEST_DECORATOR(*boost::unit_test::timeout(1))
-
-BOOST_DATA_TEST_CASE(intersect_ray_miss,
-		boost::unit_test::data::make<Ray>({
-				{{3, 3, 5}, {-1, -1, 0}},
-				{{0, 0, 5}, {0, 0, 1}},
-				{{0, 0, 5}, {0, 0, -1}},
-		}),
-		ray)
-{
-	// at(x,y) is index based
-	nodes[at(0, 0)].height = 1;
-	nodes[at(1, 0)].height = 2;
-	nodes[at(0, 1)].height = 3;
-	nodes[at(1, 1)].height = 4;
-
-	BOOST_REQUIRE(!intersectRay(ray));
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/test-geoData.cpp b/test/test-geoData.cpp
new file mode 100644
index 0000000..d79f5b8
--- /dev/null
+++ b/test/test-geoData.cpp
@@ -0,0 +1,175 @@
+#define BOOST_TEST_MODULE terrain
+#include "testHelpers.h"
+#include <boost/test/data/test_case.hpp>
+#include <boost/test/unit_test.hpp>
+#include <stream_support.h>
+
+#include <game/geoData.h>
+
+class TestTerrainMesh : public GeoData {
+public:
+	TestTerrainMesh() : GeoData {GeoData::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")} { }
+};
+
+constexpr size_t ncols = 200, nrows = 200, xllcorner = 310000, yllcorner = 490000, cellsize = 50;
+
+BOOST_FIXTURE_TEST_SUITE(ttm, TestTerrainMesh);
+
+BOOST_AUTO_TEST_CASE(loadSuccess)
+{
+	BOOST_CHECK_EQUAL(ncols * nrows, n_vertices());
+	BOOST_CHECK_EQUAL(2 * (ncols - 1) * (nrows - 1), n_faces());
+	const auto [lower, upper] = getExtents();
+	BOOST_CHECK_EQUAL(lower, glm::vec3(310000, 490000, -2.6));
+	BOOST_CHECK_EQUAL(upper, glm::vec3(320000, 500000, 571.6));
+}
+
+BOOST_AUTO_TEST_CASE(normalsAllPointUp)
+{
+	BOOST_CHECK(std::all_of(faces_begin(), faces_end(), [this](auto && vh) {
+		return normal(vh).z > 0;
+	}));
+	BOOST_CHECK(std::all_of(vertices_begin(), vertices_end(), [this](auto && vh) {
+		return normal(vh).z > 0;
+	}));
+}
+
+BOOST_AUTO_TEST_CASE(trianglesContainsPoints)
+{
+	const auto face = face_handle(0);
+	auto vertices = cfv_iter(face);
+
+	BOOST_TEST_CONTEXT(point(*vertices++) << point(*vertices++) << point(*vertices++)) {
+		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner, yllcorner}, face));
+		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner + cellsize, yllcorner + cellsize}, face));
+		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner, yllcorner + cellsize}, face));
+		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner + 1, yllcorner + 1}, face));
+		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner + 1, yllcorner + 2}, face));
+		BOOST_CHECK(!triangleContainsPoint(glm::vec2 {xllcorner + 3, yllcorner + 2}, face));
+		BOOST_CHECK(!triangleContainsPoint(glm::vec2 {xllcorner + cellsize, yllcorner}, face));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(locatePointFace)
+{
+	const PointFace pf {{310002, 490003}};
+	BOOST_CHECK(!pf.isLocated());
+	BOOST_CHECK(pf.face(this).is_valid());
+	BOOST_CHECK_EQUAL(pf.face(this).idx(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(preLocatePointFace)
+{
+	const PointFace pf {{310002, 490003}, this};
+	BOOST_CHECK(pf.isLocated());
+	BOOST_CHECK_EQUAL(pf.face(this).idx(), 0);
+}
+
+BOOST_AUTO_TEST_SUITE_END();
+
+using FindPointData = std::tuple<glm::vec2, int>;
+
+static const TestTerrainMesh fixedTerrtain;
+
+// No boundary cases as these can produce different valid results depending on starting point
+BOOST_DATA_TEST_CASE(findPointOnTerrain,
+		boost::unit_test::data::make<FindPointData>({
+				{{0, 0}, -1}, {{xllcorner, 0}, -1}, {{0, yllcorner}, -1}, {{xllcorner + 1, yllcorner + 2}, 0},
+				{{xllcorner + (cellsize * (nrows - 1)) - 2, yllcorner + (cellsize * (ncols - 1)) - 1}, 79200},
+				{{315555, 495556}, 44400}, // perf test target
+		})
+				* boost::unit_test::data::make<int>(
+						{0, 1, 2, 3, 4, 5, 6, 10, 100, 150, 200, 1000, 1234, 17439, 79201, 79200, 79199}),
+		p, fh, start)
+{
+	BOOST_CHECK_EQUAL(fh, fixedTerrtain.findPoint(p, GeoData::FaceHandle(start)).idx());
+}
+
+using FindPositionData = std::tuple<glm::vec2, float>;
+
+BOOST_DATA_TEST_CASE(findPositionAt,
+		boost::unit_test::data::make<FindPositionData>({
+				// corners
+				{{310000, 490000}, 32.8F},
+				{{310050, 490050}, 33.0F},
+				{{310000, 490050}, 32.7F},
+				{{310050, 490000}, 33.2F},
+				{{310750, 490150}, 58.4F},
+				// midpoints
+				{{310025, 490025}, 32.9F},
+				{{310025, 490050}, 32.85F},
+				{{310000, 490025}, 32.75F},
+				// other
+				{{310751, 490152}, 58.326F},
+		}),
+		p, h)
+{
+	BOOST_CHECK_CLOSE_VEC(fixedTerrtain.positionAt(p), p ^ h);
+}
+
+using FindRayIntersectData = std::tuple<glm::vec3, glm::vec3, glm::vec3>;
+
+BOOST_DATA_TEST_CASE(findRayIntersect,
+		boost::unit_test::data::make<FindRayIntersectData>({
+				{{310000, 490000, 50}, {1, 1, -2}, {310008.59, 490008.59, 32.834301}},
+				{{310000, 490000, 50}, {1, 1, -1}, {310017.12, 490017.12, 32.868526}},
+		}),
+		p, d, i)
+{
+	BOOST_CHECK_CLOSE_VEC(fixedTerrtain.intersectRay({p, d}).value(), i);
+}
+
+using WalkTerrainData = std::tuple<glm::vec2, glm::vec2, std::vector<int>>;
+
+BOOST_DATA_TEST_CASE(walkTerrain,
+		boost::unit_test::data::make<WalkTerrainData>({
+				{{310002, 490003}, {310002, 490003}, {0}},
+				{{310003, 490002}, {310003, 490002}, {1}},
+				{{310002, 490003}, {310003, 490002}, {0, 1}},
+				{{310003, 490002}, {310002, 490003}, {1, 0}},
+				{{310002, 490003}, {310202, 490003}, {0, 1, 2, 3, 4, 5, 6, 7, 8}},
+				{{310202, 490003}, {310002, 490003}, {8, 7, 6, 5, 4, 3, 2, 1, 0}},
+				{{310002, 490003}, {310002, 490203}, {0, 399, 398, 797, 796, 1195, 1194, 1593, 1592}},
+		}),
+		from, to, visits)
+{
+	std::vector<int> visited;
+	BOOST_CHECK_NO_THROW(fixedTerrtain.walk(from, to, [&visited](auto fh) {
+		visited.emplace_back(fh.idx());
+	}));
+	BOOST_CHECK_EQUAL_COLLECTIONS(visited.begin(), visited.end(), visits.begin(), visits.end());
+}
+
+BOOST_DATA_TEST_CASE(walkTerrainSetsFromFace,
+		boost::unit_test::data::make<WalkTerrainData>({
+				{{310002, 490003}, {310002, 490003}, {0}},
+				{{310003, 490002}, {310003, 490002}, {1}},
+				{{310002, 490003}, {310003, 490002}, {0, 1}},
+				{{310003, 490002}, {310002, 490003}, {1, 0}},
+		}),
+		from, to, visits)
+{
+	GeoData::PointFace pf {from};
+	BOOST_CHECK_NO_THROW(fixedTerrtain.walk(pf, to, [](auto) {}));
+	BOOST_CHECK_EQUAL(pf.face(&fixedTerrtain).idx(), visits.front());
+}
+
+BOOST_DATA_TEST_CASE(walkTerrainUntil,
+		boost::unit_test::data::make<WalkTerrainData>({
+				{{310002, 490003}, {310002, 490003}, {0}},
+				{{310003, 490002}, {310003, 490002}, {1}},
+				{{310002, 490003}, {310003, 490002}, {0, 1}},
+				{{310003, 490002}, {310002, 490003}, {1, 0}},
+				{{310002, 490003}, {310202, 490003}, {0, 1, 2, 3, 4}},
+				{{310202, 490003}, {310002, 490003}, {8, 7, 6, 5, 4}},
+				{{310002, 490003}, {310002, 490203}, {0, 399, 398, 797, 796}},
+		}),
+		from, to, visits)
+{
+	std::vector<int> visited;
+	BOOST_CHECK_NO_THROW(fixedTerrtain.walkUntil(from, to, [&visited](auto fh) {
+		visited.emplace_back(fh.idx());
+		return visited.size() >= 5;
+	}));
+	BOOST_CHECK_EQUAL_COLLECTIONS(visited.begin(), visited.end(), visits.begin(), visits.end());
+}
diff --git a/test/test-render.cpp b/test/test-render.cpp
index b16f241..fb2a71b 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -26,8 +26,7 @@ class TestScene : public SceneProvider {
 	std::shared_ptr<RailVehicle> train1, train2;
 
 	Terrain terrain {[]() {
-		auto gd = std::make_shared<GeoData>(GeoData::Limits {{0, 0}, {100, 100}});
-		gd->generateRandom();
+		auto gd = std::make_shared<GeoData>(GeoData::createFlat({0, 0}, {1000, 1000}, 1));
 		return gd;
 	}()};
 
diff --git a/test/test-terrain.cpp b/test/test-terrain.cpp
deleted file mode 100644
index 71fc1ec..0000000
--- a/test/test-terrain.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-#define BOOST_TEST_MODULE terrain
-#include "testHelpers.h"
-#include <boost/test/data/test_case.hpp>
-#include <boost/test/unit_test.hpp>
-#include <stream_support.h>
-
-#include <game/terrain2.h>
-
-class TestTerrainMesh : public TerrainMesh {
-public:
-	TestTerrainMesh() : TerrainMesh {TerrainMesh::loadFromAsciiGrid(FIXTURESDIR "height/SD19.asc")} { }
-};
-
-constexpr size_t ncols = 200, nrows = 200, xllcorner = 310000, yllcorner = 490000, cellsize = 50;
-
-BOOST_FIXTURE_TEST_SUITE(ttm, TestTerrainMesh);
-
-BOOST_AUTO_TEST_CASE(loadSuccess)
-{
-	BOOST_CHECK_EQUAL(ncols * nrows, n_vertices());
-	BOOST_CHECK_EQUAL(2 * (ncols - 1) * (nrows - 1), n_faces());
-	const auto [lower, upper] = getExtents();
-	BOOST_CHECK_EQUAL(lower, glm::vec3(310000, 490000, -2.6));
-	BOOST_CHECK_EQUAL(upper, glm::vec3(320000, 500000, 571.6));
-}
-
-BOOST_AUTO_TEST_CASE(normalsAllPointUp)
-{
-	BOOST_CHECK(std::all_of(faces_begin(), faces_end(), [this](auto && vh) {
-		return normal(vh).z > 0;
-	}));
-	BOOST_CHECK(std::all_of(vertices_begin(), vertices_end(), [this](auto && vh) {
-		return normal(vh).z > 0;
-	}));
-}
-
-BOOST_AUTO_TEST_CASE(trianglesContainsPoints)
-{
-	const auto face = face_handle(0);
-	auto vertices = cfv_iter(face);
-
-	BOOST_TEST_CONTEXT(point(*vertices++) << point(*vertices++) << point(*vertices++)) {
-		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner, yllcorner}, face));
-		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner + cellsize, yllcorner + cellsize}, face));
-		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner, yllcorner + cellsize}, face));
-		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner + 1, yllcorner + 1}, face));
-		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner + 1, yllcorner + 2}, face));
-		BOOST_CHECK(!triangleContainsPoint(glm::vec2 {xllcorner + 3, yllcorner + 2}, face));
-		BOOST_CHECK(!triangleContainsPoint(glm::vec2 {xllcorner + cellsize, yllcorner}, face));
-	}
-}
-
-BOOST_AUTO_TEST_CASE(locatePointFace)
-{
-	const PointFace pf {{310002, 490003}};
-	BOOST_CHECK(!pf.isLocated());
-	BOOST_CHECK(pf.face(this).is_valid());
-	BOOST_CHECK_EQUAL(pf.face(this).idx(), 0);
-}
-
-BOOST_AUTO_TEST_CASE(preLocatePointFace)
-{
-	const PointFace pf {{310002, 490003}, this};
-	BOOST_CHECK(pf.isLocated());
-	BOOST_CHECK_EQUAL(pf.face(this).idx(), 0);
-}
-
-BOOST_AUTO_TEST_SUITE_END();
-
-using FindPointData = std::tuple<glm::vec2, int>;
-
-static const TestTerrainMesh fixedTerrtain;
-
-// No boundary cases as these can produce different valid results depending on starting point
-BOOST_DATA_TEST_CASE(findPointOnTerrain,
-		boost::unit_test::data::make<FindPointData>({
-				{{0, 0}, -1}, {{xllcorner, 0}, -1}, {{0, yllcorner}, -1}, {{xllcorner + 1, yllcorner + 2}, 0},
-				{{xllcorner + (cellsize * (nrows - 1)) - 2, yllcorner + (cellsize * (ncols - 1)) - 1}, 79200},
-				{{315555, 495556}, 44400}, // perf test target
-		})
-				* boost::unit_test::data::make<int>(
-						{0, 1, 2, 3, 4, 5, 6, 10, 100, 150, 200, 1000, 1234, 17439, 79201, 79200, 79199}),
-		p, fh, start)
-{
-	BOOST_CHECK_EQUAL(fh, fixedTerrtain.findPoint(p, TerrainMesh::FaceHandle(start)).idx());
-}
-
-using FindPositionData = std::tuple<glm::vec2, float>;
-
-BOOST_DATA_TEST_CASE(findPositionAt,
-		boost::unit_test::data::make<FindPositionData>({
-				// corners
-				{{310000, 490000}, 32.8F},
-				{{310050, 490050}, 33.0F},
-				{{310000, 490050}, 32.7F},
-				{{310050, 490000}, 33.2F},
-				{{310750, 490150}, 58.4F},
-				// midpoints
-				{{310025, 490025}, 32.9F},
-				{{310025, 490050}, 32.85F},
-				{{310000, 490025}, 32.75F},
-				// other
-				{{310751, 490152}, 58.326F},
-		}),
-		p, h)
-{
-	BOOST_CHECK_CLOSE_VEC(fixedTerrtain.positionAt(p), p ^ h);
-}
-
-using FindRayIntersectData = std::tuple<glm::vec3, glm::vec3, glm::vec3>;
-
-BOOST_DATA_TEST_CASE(findRayIntersect,
-		boost::unit_test::data::make<FindRayIntersectData>({
-				{{310000, 490000, 50}, {1, 1, -2}, {310008.59, 490008.59, 32.834301}},
-				{{310000, 490000, 50}, {1, 1, -1}, {310017.12, 490017.12, 32.868526}},
-		}),
-		p, d, i)
-{
-	BOOST_CHECK_CLOSE_VEC(fixedTerrtain.intersectRay({p, d}).value(), i);
-}
-
-using WalkTerrainData = std::tuple<glm::vec2, glm::vec2, std::vector<int>>;
-
-BOOST_DATA_TEST_CASE(walkTerrain,
-		boost::unit_test::data::make<WalkTerrainData>({
-				{{310002, 490003}, {310002, 490003}, {0}},
-				{{310003, 490002}, {310003, 490002}, {1}},
-				{{310002, 490003}, {310003, 490002}, {0, 1}},
-				{{310003, 490002}, {310002, 490003}, {1, 0}},
-				{{310002, 490003}, {310202, 490003}, {0, 1, 2, 3, 4, 5, 6, 7, 8}},
-				{{310202, 490003}, {310002, 490003}, {8, 7, 6, 5, 4, 3, 2, 1, 0}},
-				{{310002, 490003}, {310002, 490203}, {0, 399, 398, 797, 796, 1195, 1194, 1593, 1592}},
-		}),
-		from, to, visits)
-{
-	std::vector<int> visited;
-	BOOST_CHECK_NO_THROW(fixedTerrtain.walk(from, to, [&visited](auto fh) {
-		visited.emplace_back(fh.idx());
-	}));
-	BOOST_CHECK_EQUAL_COLLECTIONS(visited.begin(), visited.end(), visits.begin(), visits.end());
-}
-
-BOOST_DATA_TEST_CASE(walkTerrainSetsFromFace,
-		boost::unit_test::data::make<WalkTerrainData>({
-				{{310002, 490003}, {310002, 490003}, {0}},
-				{{310003, 490002}, {310003, 490002}, {1}},
-				{{310002, 490003}, {310003, 490002}, {0, 1}},
-				{{310003, 490002}, {310002, 490003}, {1, 0}},
-		}),
-		from, to, visits)
-{
-	TerrainMesh::PointFace pf {from};
-	BOOST_CHECK_NO_THROW(fixedTerrtain.walk(pf, to, [](auto) {}));
-	BOOST_CHECK_EQUAL(pf.face(&fixedTerrtain).idx(), visits.front());
-}
-
-BOOST_DATA_TEST_CASE(walkTerrainUntil,
-		boost::unit_test::data::make<WalkTerrainData>({
-				{{310002, 490003}, {310002, 490003}, {0}},
-				{{310003, 490002}, {310003, 490002}, {1}},
-				{{310002, 490003}, {310003, 490002}, {0, 1}},
-				{{310003, 490002}, {310002, 490003}, {1, 0}},
-				{{310002, 490003}, {310202, 490003}, {0, 1, 2, 3, 4}},
-				{{310202, 490003}, {310002, 490003}, {8, 7, 6, 5, 4}},
-				{{310002, 490003}, {310002, 490203}, {0, 399, 398, 797, 796}},
-		}),
-		from, to, visits)
-{
-	std::vector<int> visited;
-	BOOST_CHECK_NO_THROW(fixedTerrtain.walkUntil(from, to, [&visited](auto fh) {
-		visited.emplace_back(fh.idx());
-		return visited.size() >= 5;
-	}));
-	BOOST_CHECK_EQUAL_COLLECTIONS(visited.begin(), visited.end(), visits.begin(), visits.end());
-}
diff --git a/ui/gameMainWindow.cpp b/ui/gameMainWindow.cpp
index c35c9c6..6981c54 100644
--- a/ui/gameMainWindow.cpp
+++ b/ui/gameMainWindow.cpp
@@ -31,7 +31,7 @@ public:
 GameMainWindow::GameMainWindow(size_t w, size_t h) :
 	Window {w, h, "I Like Trains", SDL_WINDOW_OPENGL}, SceneRenderer {Window::size, 0}
 {
-	uiComponents.create<ManualCameraController>(glm::vec2 {-1150, -1150});
+	uiComponents.create<ManualCameraController>(glm::vec2 {315000, 495000});
 	auto gms = uiComponents.create<GameMainSelector>(&camera, glm::vec2 {w, h});
 	uiComponents.create<GameMainToolbar>(gms.get());
 }
-- 
cgit v1.2.3


From 5ed36466b48aa347277c70422eb00bee264a5c8b Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 4 Nov 2023 17:07:58 +0000
Subject: Simplify some logic with the triangle construct

---
 game/geoData.cpp      | 26 ++++++++++----------------
 game/geoData.h        | 10 ++++++++--
 test/test-geoData.cpp |  3 +--
 3 files changed, 19 insertions(+), 20 deletions(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index d32bf8c..5e49c94 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -135,8 +135,7 @@ namespace {
 OpenMesh::FaceHandle
 GeoData::findPoint(glm::vec2 p, OpenMesh::FaceHandle f) const
 {
-	ConstFaceVertexIter vertices;
-	while (f.is_valid() && !triangleContainsPoint(p, vertices = cfv_iter(f))) {
+	while (f.is_valid() && !triangleContainsPoint(p, triangle<2>(f))) {
 		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
 			f = opposite_face_handle(*next);
 			if (f.is_valid()) {
@@ -156,7 +155,7 @@ glm::vec3
 GeoData::positionAt(const PointFace & p) const
 {
 	glm::vec3 out {};
-	Triangle<3> t {this, fv_range(p.face(this))};
+	const auto t = triangle<3>(p.face(this));
 	glm::intersectLineTriangle(p.point ^ 0.F, up, t[0], t[1], t[2], out);
 	return p.point ^ out[0];
 }
@@ -174,7 +173,7 @@ GeoData::intersectRay(const Ray & ray, FaceHandle face) const
 	walkUntil(PointFace {ray.start, face}, ray.start + (ray.direction * 10000.F), [&out, &ray, this](FaceHandle face) {
 		glm::vec2 bari {};
 		float dist {};
-		Triangle<3> t {this, fv_range(face)};
+		const auto t = triangle<3>(face);
 		if (glm::intersectRayTriangle(ray.start, ray.direction, t[0], t[1], t[2], bari, dist)) {
 			out = t * bari;
 			return true;
@@ -216,23 +215,18 @@ GeoData::walkUntil(const PointFace & from, const glm::vec2 to, const std::functi
 }
 
 bool
-GeoData::triangleContainsPoint(const glm::vec2 p, const glm::vec2 a, const glm::vec2 b, const glm::vec2 c)
+GeoData::triangleContainsPoint(const glm::vec2 p, const Triangle<2> & t)
 {
-	const auto det = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+	const auto mul = [](const glm::vec2 a, const glm::vec2 b, const glm::vec2 c) {
+		return (a.x - b.x) * (c.y - b.y) - (a.y - b.y) * (c.x - b.x);
+	};
+	const auto det = mul(t[1], t[0], t[2]);
 
-	return det * ((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x)) >= 0
-			&& det * ((c.x - b.x) * (p.y - b.y) - (c.y - b.y) * (p.x - b.x)) >= 0
-			&& det * ((a.x - c.x) * (p.y - c.y) - (a.y - c.y) * (p.x - c.x)) >= 0;
+	return det * mul(t[1], t[0], p) >= 0 && det * mul(t[2], t[1], p) >= 0 && det * mul(t[0], t[2], p) >= 0;
 }
 
 bool
 GeoData::triangleContainsPoint(const glm::vec2 p, FaceHandle face) const
 {
-	return triangleContainsPoint(p, cfv_iter(face));
-}
-
-bool
-GeoData::triangleContainsPoint(const glm::vec2 p, ConstFaceVertexIter vertices) const
-{
-	return triangleContainsPoint(p, point(*vertices++), point(*vertices++), point(*vertices++));
+	return triangleContainsPoint(p, triangle<2>(face));
 }
diff --git a/game/geoData.h b/game/geoData.h
index 3a4f98e..b8561d0 100644
--- a/game/geoData.h
+++ b/game/geoData.h
@@ -85,9 +85,15 @@ public:
 	}
 
 protected:
-	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const glm::vec2, const glm::vec2, const glm::vec2);
+	template<glm::length_t Dim>
+	[[nodiscard]] Triangle<Dim>
+	triangle(FaceHandle f) const
+	{
+		return {this, fv_range(f)};
+	}
+
+	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const Triangle<2> &);
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
-	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, ConstFaceVertexIter) const;
 
 private:
 	glm::vec3 lowerExtent {}, upperExtent {};
diff --git a/test/test-geoData.cpp b/test/test-geoData.cpp
index d79f5b8..b33c61e 100644
--- a/test/test-geoData.cpp
+++ b/test/test-geoData.cpp
@@ -37,9 +37,8 @@ BOOST_AUTO_TEST_CASE(normalsAllPointUp)
 BOOST_AUTO_TEST_CASE(trianglesContainsPoints)
 {
 	const auto face = face_handle(0);
-	auto vertices = cfv_iter(face);
 
-	BOOST_TEST_CONTEXT(point(*vertices++) << point(*vertices++) << point(*vertices++)) {
+	BOOST_TEST_CONTEXT(GeoData::Triangle<2>(this, fv_range(face))) {
 		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner, yllcorner}, face));
 		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner + cellsize, yllcorner + cellsize}, face));
 		BOOST_CHECK(triangleContainsPoint(glm::vec2 {xllcorner, yllcorner + cellsize}, face));
-- 
cgit v1.2.3


From f53816a8fd9ec15ef03b5bf45472eda46e53c1ad Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 4 Nov 2023 21:05:35 +0000
Subject: Refactor to further simplify line/point operations

Adds another perf test
---
 game/geoData.cpp      | 18 +++++++++---------
 test/perf-geoData.cpp | 13 +++++++++++++
 2 files changed, 22 insertions(+), 9 deletions(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index 5e49c94..c58658a 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -111,12 +111,16 @@ GeoData::PointFace::face(const GeoData * mesh) const
 }
 
 namespace {
-	[[nodiscard]] constexpr inline bool
-	pointLeftOfLine(const glm::vec2 p, const glm::vec2 e1, const glm::vec2 e2)
+	template<template<typename> typename Op>
+	[[nodiscard]] constexpr inline auto
+	pointLineOp(const glm::vec2 p, const glm::vec2 e1, const glm::vec2 e2)
 	{
-		return (e2.x - e1.x) * (p.y - e1.y) > (e2.y - e1.y) * (p.x - e1.x);
+		return Op {}((e2.x - e1.x) * (p.y - e1.y), (e2.y - e1.y) * (p.x - e1.x));
 	}
 
+	constexpr auto pointLeftOfLine = pointLineOp<std::greater>;
+	constexpr auto pointLeftOfOrOnLine = pointLineOp<std::greater_equal>;
+
 	static_assert(pointLeftOfLine({1, 2}, {1, 1}, {2, 2}));
 	static_assert(pointLeftOfLine({2, 1}, {2, 2}, {1, 1}));
 	static_assert(pointLeftOfLine({2, 2}, {1, 2}, {2, 1}));
@@ -217,12 +221,8 @@ GeoData::walkUntil(const PointFace & from, const glm::vec2 to, const std::functi
 bool
 GeoData::triangleContainsPoint(const glm::vec2 p, const Triangle<2> & t)
 {
-	const auto mul = [](const glm::vec2 a, const glm::vec2 b, const glm::vec2 c) {
-		return (a.x - b.x) * (c.y - b.y) - (a.y - b.y) * (c.x - b.x);
-	};
-	const auto det = mul(t[1], t[0], t[2]);
-
-	return det * mul(t[1], t[0], p) >= 0 && det * mul(t[2], t[1], p) >= 0 && det * mul(t[0], t[2], p) >= 0;
+	return pointLeftOfOrOnLine(p, t[0], t[1]) && pointLeftOfOrOnLine(p, t[1], t[2])
+			&& pointLeftOfOrOnLine(p, t[2], t[0]);
 }
 
 bool
diff --git a/test/perf-geoData.cpp b/test/perf-geoData.cpp
index e1546c1..2d79a90 100644
--- a/test/perf-geoData.cpp
+++ b/test/perf-geoData.cpp
@@ -11,8 +11,21 @@ namespace {
 			benchmark::DoNotOptimize(tm.findPoint({315555, 495556}));
 		}
 	}
+
+	void
+	terrain_walk(benchmark::State & state)
+	{
+		const glm::vec2 point {310001, 490000};
+		const GeoData::PointFace start {point, tm.findPoint(point)};
+		for (auto _ : state) {
+			tm.walk(start, {319999, 500000}, [](auto f) {
+				benchmark::DoNotOptimize(f);
+			});
+		}
+	}
 }
 
 BENCHMARK(terrain_findPoint);
+BENCHMARK(terrain_walk);
 
 BENCHMARK_MAIN();
-- 
cgit v1.2.3


From 04078dbb3fe4acd09d150e016c2b2e0d5d036950 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 5 Nov 2023 13:07:32 +0000
Subject: Add methods to walk the boundary of the terrain mesh

---
 game/geoData.cpp      | 45 +++++++++++++++++++++++++++++++++++++++++++++
 game/geoData.h        |  6 ++++++
 test/perf-geoData.cpp | 11 +++++++++++
 test/test-geoData.cpp | 10 ++++++++++
 4 files changed, 72 insertions(+)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index c58658a..f9c11bf 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -218,6 +218,43 @@ GeoData::walkUntil(const PointFace & from, const glm::vec2 to, const std::functi
 	}
 }
 
+void
+GeoData::boundaryWalk(const std::function<void(HalfedgeHandle)> & op) const
+{
+	boundaryWalk(op, findBoundaryStart());
+}
+
+void
+GeoData::boundaryWalk(const std::function<void(HalfedgeHandle)> & op, HalfedgeHandle start) const
+{
+	assert(is_boundary(start));
+	boundaryWalkUntil(
+			[&op](auto heh) {
+		op(heh);
+				return false;
+			},
+			start);
+}
+
+void
+GeoData::boundaryWalkUntil(const std::function<bool(HalfedgeHandle)> & op) const
+{
+	boundaryWalkUntil(op, findBoundaryStart());
+}
+
+void
+GeoData::boundaryWalkUntil(const std::function<bool(HalfedgeHandle)> & op, HalfedgeHandle start) const
+{
+	assert(is_boundary(start));
+	if (!op(start)) {
+		for (auto heh = next_halfedge_handle(start); heh != start; heh = next_halfedge_handle(heh)) {
+			if (op(heh)) {
+				break;
+			}
+		}
+	}
+}
+
 bool
 GeoData::triangleContainsPoint(const glm::vec2 p, const Triangle<2> & t)
 {
@@ -230,3 +267,11 @@ GeoData::triangleContainsPoint(const glm::vec2 p, FaceHandle face) const
 {
 	return triangleContainsPoint(p, triangle<2>(face));
 }
+
+GeoData::HalfedgeHandle
+GeoData::findBoundaryStart() const
+{
+	return *std::find_if(halfedges_begin(), halfedges_end(), [this](const auto heh) {
+		return is_boundary(heh);
+	});
+}
diff --git a/game/geoData.h b/game/geoData.h
index b8561d0..15d7e24 100644
--- a/game/geoData.h
+++ b/game/geoData.h
@@ -78,6 +78,11 @@ public:
 	void walk(const PointFace & from, const glm::vec2 to, const std::function<void(FaceHandle)> & op) const;
 	void walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const;
 
+	void boundaryWalk(const std::function<void(HalfedgeHandle)> &) const;
+	void boundaryWalk(const std::function<void(HalfedgeHandle)> &, HalfedgeHandle start) const;
+	void boundaryWalkUntil(const std::function<bool(HalfedgeHandle)> &) const;
+	void boundaryWalkUntil(const std::function<bool(HalfedgeHandle)> &, HalfedgeHandle start) const;
+
 	[[nodiscard]] auto
 	getExtents() const
 	{
@@ -94,6 +99,7 @@ protected:
 
 	[[nodiscard]] static bool triangleContainsPoint(const glm::vec2, const Triangle<2> &);
 	[[nodiscard]] bool triangleContainsPoint(const glm::vec2, FaceHandle) const;
+	[[nodiscard]] HalfedgeHandle findBoundaryStart() const;
 
 private:
 	glm::vec3 lowerExtent {}, upperExtent {};
diff --git a/test/perf-geoData.cpp b/test/perf-geoData.cpp
index 2d79a90..4fed632 100644
--- a/test/perf-geoData.cpp
+++ b/test/perf-geoData.cpp
@@ -23,9 +23,20 @@ namespace {
 			});
 		}
 	}
+
+	void
+	terrain_walkBoundary(benchmark::State & state)
+	{
+		for (auto _ : state) {
+			tm.boundaryWalk([](auto heh) {
+				benchmark::DoNotOptimize(heh);
+			});
+		}
+	}
 }
 
 BENCHMARK(terrain_findPoint);
 BENCHMARK(terrain_walk);
+BENCHMARK(terrain_walkBoundary);
 
 BENCHMARK_MAIN();
diff --git a/test/test-geoData.cpp b/test/test-geoData.cpp
index 258bd9c..34c9cb6 100644
--- a/test/test-geoData.cpp
+++ b/test/test-geoData.cpp
@@ -118,6 +118,16 @@ BOOST_DATA_TEST_CASE(findRayIntersect,
 	BOOST_CHECK_CLOSE_VEC(fixedTerrtain.intersectRay({p, d}).value(), i);
 }
 
+BOOST_AUTO_TEST_CASE(boundaryWalk)
+{
+	size_t count {};
+	fixedTerrtain.boundaryWalk([&count](auto heh) {
+		BOOST_CHECK(fixedTerrtain.is_boundary(heh));
+		count++;
+	});
+	BOOST_CHECK_EQUAL(count, 2 * (ncols + nrows - 2));
+}
+
 using WalkTerrainData = std::tuple<glm::vec2, glm::vec2, std::vector<int>>;
 
 BOOST_DATA_TEST_CASE(walkTerrain,
-- 
cgit v1.2.3


From eb5dea3d035c61327543d7ab527d897ef3768570 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 5 Nov 2023 14:21:14 +0000
Subject: Fix and split linesCross

Previous tested they crossed in a specific direction, which is wrong but useful. Adds
linesCrossLtR for this use case.
---
 game/geoData.cpp | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index f9c11bf..78f753f 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -128,12 +128,23 @@ namespace {
 
 	[[nodiscard]] constexpr inline bool
 	linesCross(const glm::vec2 a1, const glm::vec2 a2, const glm::vec2 b1, const glm::vec2 b2)
+	{
+		return (pointLeftOfLine(a2, b1, b2) == pointLeftOfLine(a1, b2, b1))
+				&& (pointLeftOfLine(b1, a1, a2) == pointLeftOfLine(b2, a2, a1));
+	}
+
+	static_assert(linesCross({1, 1}, {2, 2}, {1, 2}, {2, 1}));
+	static_assert(linesCross({2, 2}, {1, 1}, {1, 2}, {2, 1}));
+
+	[[nodiscard]] constexpr inline bool
+	linesCrossLtR(const glm::vec2 a1, const glm::vec2 a2, const glm::vec2 b1, const glm::vec2 b2)
 	{
 		return pointLeftOfLine(a2, b1, b2) && pointLeftOfLine(a1, b2, b1) && pointLeftOfLine(b1, a1, a2)
 				&& pointLeftOfLine(b2, a2, a1);
 	}
 
-	static_assert(linesCross({1, 1}, {2, 2}, {1, 2}, {2, 1}));
+	static_assert(linesCrossLtR({1, 1}, {2, 2}, {1, 2}, {2, 1}));
+	static_assert(!linesCrossLtR({2, 2}, {1, 1}, {1, 2}, {2, 1}));
 }
 
 OpenMesh::FaceHandle
@@ -208,7 +219,7 @@ GeoData::walkUntil(const PointFace & from, const glm::vec2 to, const std::functi
 			if (f.is_valid() && f != previousFace) {
 				const auto e1 = point(to_vertex_handle(*next));
 				const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(*next)));
-				if (linesCross(from.point, to, e1, e2)) {
+				if (linesCrossLtR(from.point, to, e1, e2)) {
 					previousFace = f;
 					break;
 				}
-- 
cgit v1.2.3


From acca54f3a12225454633dca2d56506c0dcebb653 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 5 Nov 2023 15:37:13 +0000
Subject: Fix calculating extents

---
 game/geoData.cpp      | 4 ++--
 test/test-geoData.cpp | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index 78f753f..781b41e 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -25,8 +25,8 @@ GeoData::loadFromAsciiGrid(const std::filesystem::path & input)
 	vertices.reserve(ncols * nrows);
 	GeoData mesh;
 	mesh.lowerExtent = {xllcorner, yllcorner, std::numeric_limits<float>::max()};
-	mesh.upperExtent
-			= {xllcorner + (cellsize * ncols), yllcorner + (cellsize * nrows), std::numeric_limits<float>::min()};
+	mesh.upperExtent = {xllcorner + (cellsize * (ncols - 1)), yllcorner + (cellsize * (nrows - 1)),
+			std::numeric_limits<float>::min()};
 	for (size_t row = 0; row < nrows; ++row) {
 		for (size_t col = 0; col < ncols; ++col) {
 			float height = 0;
diff --git a/test/test-geoData.cpp b/test/test-geoData.cpp
index 34c9cb6..2ea9b26 100644
--- a/test/test-geoData.cpp
+++ b/test/test-geoData.cpp
@@ -21,7 +21,7 @@ BOOST_AUTO_TEST_CASE(loadSuccess)
 	BOOST_CHECK_EQUAL(2 * (ncols - 1) * (nrows - 1), n_faces());
 	const auto [lower, upper] = getExtents();
 	BOOST_CHECK_EQUAL(lower, glm::vec3(310000, 490000, -2.6));
-	BOOST_CHECK_EQUAL(upper, glm::vec3(320000, 500000, 571.6));
+	BOOST_CHECK_EQUAL(upper, glm::vec3(319950, 499950, 571.6));
 }
 
 BOOST_AUTO_TEST_CASE(normalsAllPointUp)
-- 
cgit v1.2.3


From 58402765133fab24d08b64f3752553bd2b8393b9 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 5 Nov 2023 15:52:02 +0000
Subject: Fix todo for handling a terrain walk from outside the mesh

---
 game/geoData.cpp      | 22 ++++++++++++++++++++--
 game/geoData.h        |  2 ++
 test/test-geoData.cpp |  5 +++++
 3 files changed, 27 insertions(+), 2 deletions(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index 781b41e..61dedda 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -210,8 +210,10 @@ GeoData::walk(const PointFace & from, const glm::vec2 to, const std::function<vo
 void
 GeoData::walkUntil(const PointFace & from, const glm::vec2 to, const std::function<bool(FaceHandle)> & op) const
 {
-	assert(from.face(this).is_valid()); // TODO replace with a boundary search
 	auto f = from.face(this);
+	if (!f.is_valid()) {
+		f = opposite_face_handle(findEntry(from.point, to));
+	}
 	FaceHandle previousFace;
 	while (f.is_valid() && !op(f)) {
 		for (auto next = cfh_iter(f); next.is_valid(); ++next) {
@@ -241,7 +243,7 @@ GeoData::boundaryWalk(const std::function<void(HalfedgeHandle)> & op, HalfedgeHa
 	assert(is_boundary(start));
 	boundaryWalkUntil(
 			[&op](auto heh) {
-		op(heh);
+				op(heh);
 				return false;
 			},
 			start);
@@ -266,6 +268,22 @@ GeoData::boundaryWalkUntil(const std::function<bool(HalfedgeHandle)> & op, Halfe
 	}
 }
 
+GeoData::HalfedgeHandle
+GeoData::findEntry(const glm::vec2 from, const glm::vec2 to) const
+{
+	HalfedgeHandle entry;
+	boundaryWalkUntil([this, from, to, &entry](auto he) {
+		const auto e1 = point(to_vertex_handle(he));
+		const auto e2 = point(to_vertex_handle(opposite_halfedge_handle(he)));
+		if (linesCrossLtR(from, to, e1, e2)) {
+			entry = he;
+			return true;
+		}
+		return false;
+	});
+	return entry;
+}
+
 bool
 GeoData::triangleContainsPoint(const glm::vec2 p, const Triangle<2> & t)
 {
diff --git a/game/geoData.h b/game/geoData.h
index 15d7e24..474731b 100644
--- a/game/geoData.h
+++ b/game/geoData.h
@@ -83,6 +83,8 @@ public:
 	void boundaryWalkUntil(const std::function<bool(HalfedgeHandle)> &) const;
 	void boundaryWalkUntil(const std::function<bool(HalfedgeHandle)> &, HalfedgeHandle start) const;
 
+	[[nodiscard]] HalfedgeHandle findEntry(const glm::vec2 from, const glm::vec2 to) const;
+
 	[[nodiscard]] auto
 	getExtents() const
 	{
diff --git a/test/test-geoData.cpp b/test/test-geoData.cpp
index 2ea9b26..447ab37 100644
--- a/test/test-geoData.cpp
+++ b/test/test-geoData.cpp
@@ -139,6 +139,11 @@ BOOST_DATA_TEST_CASE(walkTerrain,
 				{{310002, 490003}, {310202, 490003}, {0, 1, 2, 3, 4, 5, 6, 7, 8}},
 				{{310202, 490003}, {310002, 490003}, {8, 7, 6, 5, 4, 3, 2, 1, 0}},
 				{{310002, 490003}, {310002, 490203}, {0, 399, 398, 797, 796, 1195, 1194, 1593, 1592}},
+				{{310002, 490003}, {309999, 489999}, {0}},
+				{{309999, 489999}, {310002, 490003}, {0}},
+				{{320002, 500003}, {319949, 499948}, {79201}},
+				{{309999, 490003}, {310004, 489997}, {0, 1}},
+				{{310004, 489997}, {309999, 490003}, {1, 0}},
 		}),
 		from, to, visits)
 {
-- 
cgit v1.2.3


From d6e99a696aa582b81018078b68f6600c8030d643 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Tue, 7 Nov 2023 02:51:42 +0000
Subject: WIP typedefing all the things - headers

---
 application/main.cpp           |  5 ++--
 assetFactory/factoryMesh.h     |  3 ++-
 assetFactory/mutation.h        |  7 ++---
 assetFactory/shape.h           |  3 ++-
 assetFactory/texturePacker.cpp |  4 +--
 assetFactory/texturePacker.h   |  7 ++---
 config/types.h                 | 34 +++++++++++++++++++++++
 game/geoData.h                 | 33 ++++++++++++-----------
 game/network/link.h            | 12 ++++-----
 game/network/network.h         | 42 ++++++++++++++---------------
 game/network/network.impl.h    | 12 ++++-----
 game/network/rail.h            | 10 +++----
 game/selectable.h              |  3 ++-
 game/vehicles/railVehicle.h    |  2 +-
 game/vehicles/train.h          |  2 +-
 gfx/gl/bufferedLocation.h      | 14 +++++-----
 gfx/gl/camera.cpp              |  4 +--
 gfx/gl/camera.h                | 25 ++++++++---------
 gfx/gl/sceneRenderer.cpp       |  2 +-
 gfx/gl/sceneRenderer.h         | 10 +++----
 gfx/gl/sceneShader.h           |  5 ++--
 gfx/gl/shadowMapper.cpp        |  2 +-
 gfx/gl/shadowMapper.h          |  9 ++++---
 gfx/gl/uiShader.h              |  3 ++-
 gfx/models/texture.cpp         |  1 +
 gfx/models/texture.h           |  5 ++--
 gfx/models/tga.h               |  3 ++-
 gfx/models/vertex.h            | 12 ++++-----
 lib/geometricPlane.h           | 10 ++++---
 lib/location.h                 | 12 +++++----
 lib/maths.h                    | 61 +++++++++++++++++++++---------------------
 lib/ray.h                      | 15 ++++++-----
 test/test-assetFactory.cpp     |  5 ++--
 test/testRenderOutput.h        |  7 ++---
 test/testStructures.h          |  5 ++--
 ui/builders/freeExtend.h       |  2 +-
 ui/builders/straight.h         |  4 +--
 ui/gameMainSelector.cpp        |  2 +-
 ui/gameMainSelector.h          |  3 ++-
 ui/manualCameraController.h    |  4 +--
 ui/window.h                    |  2 +-
 41 files changed, 231 insertions(+), 175 deletions(-)
 create mode 100644 config/types.h

(limited to 'game')

diff --git a/application/main.cpp b/application/main.cpp
index 0e880c0..ffdaf63 100644
--- a/application/main.cpp
+++ b/application/main.cpp
@@ -26,7 +26,6 @@
 #include <ui/applicationBase.h>
 #include <ui/gameMainWindow.h>
 #include <ui/window.h>
-#include <vector>
 
 static const int DISPLAY_WIDTH = 1280;
 static const int DISPLAY_HEIGHT = 1024;
@@ -49,10 +48,10 @@ public:
 
 		{
 			auto rl = world.create<RailLinks>();
-			const glm::vec3 j {-1120, -1100, 3}, k {-1100, -1000, 15}, l {-1000, -800, 20}, m {-900, -600, 30},
+			const Position3D j {-1120, -1100, 3}, k {-1100, -1000, 15}, l {-1000, -800, 20}, m {-900, -600, 30},
 					n {-600, -500, 32}, o {-500, -800, 30}, p {-600, -900, 25}, q {-1025, -1175, 10},
 					r {-925, -1075, 10};
-			const glm::vec3 s {-1100, -500, 15}, t {-1100, -450, 15}, u {-1000, -400, 15};
+			const Position3D s {-1100, -500, 15}, t {-1100, -450, 15}, u {-1000, -400, 15};
 			auto l3 = rl->addLinksBetween(j, k);
 			rl->addLinksBetween(k, l);
 			rl->addLinksBetween(l, m);
diff --git a/assetFactory/factoryMesh.h b/assetFactory/factoryMesh.h
index f71c737..b09b54f 100644
--- a/assetFactory/factoryMesh.h
+++ b/assetFactory/factoryMesh.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include "gfx/models/mesh.h"
 #include "stdTypeDefs.h"
 #include "use.h"
@@ -9,7 +10,7 @@ public:
 	Mesh::Ptr createMesh() const;
 
 	std::string id;
-	glm::vec3 size;
+	Size3D size;
 	Use::Collection uses;
 
 private:
diff --git a/assetFactory/mutation.h b/assetFactory/mutation.h
index 2432174..b571dea 100644
--- a/assetFactory/mutation.h
+++ b/assetFactory/mutation.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include "persistence.h"
 #include <glm/mat4x4.hpp>
 #include <glm/vec3.hpp>
@@ -13,9 +14,9 @@ struct Mutation {
 
 	float relativeLevelOfDetail() const;
 
-	glm::vec3 position {};
-	glm::vec3 rotation {};
-	glm::vec3 scale {1};
+	Position3D position {};
+	Rotation3D rotation {};
+	Scale3D scale {1};
 
 protected:
 	bool persist(Persistence::PersistenceStore & store);
diff --git a/assetFactory/shape.h b/assetFactory/shape.h
index ea3e4e7..136e24f 100644
--- a/assetFactory/shape.h
+++ b/assetFactory/shape.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include "modelFactoryMesh_fwd.h"
 #include "stdTypeDefs.h"
 #include <OpenMesh/Core/Mesh/Handles.hh>
@@ -21,5 +22,5 @@ public:
 	virtual CreatedFaces createMesh(ModelFactoryMesh &, float levelOfDetailFactor) const = 0;
 
 	static std::vector<OpenMesh::VertexHandle> addToMesh(
-			ModelFactoryMesh & mesh, const std::span<const glm::vec3> vertices);
+			ModelFactoryMesh & mesh, const std::span<const Position3D> vertices);
 };
diff --git a/assetFactory/texturePacker.cpp b/assetFactory/texturePacker.cpp
index dbafc4b..0d0fdb6 100644
--- a/assetFactory/texturePacker.cpp
+++ b/assetFactory/texturePacker.cpp
@@ -14,9 +14,7 @@ TexturePacker::TexturePacker(std::span<const Image> in) :
 	std::sort(sortedIndexes.rbegin(), sortedIndexes.rend(), [this](const auto a, const auto b) {
 		return area(inputImages[a]) < area(inputImages[b]);
 	});
-	int mts;
-	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mts);
-	maxTextureSize = static_cast<unsigned int>(mts);
+	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
 }
 
 TexturePacker::Result
diff --git a/assetFactory/texturePacker.h b/assetFactory/texturePacker.h
index 93413eb..05e3204 100644
--- a/assetFactory/texturePacker.h
+++ b/assetFactory/texturePacker.h
@@ -1,13 +1,14 @@
 #pragma once
 
+#include "config/types.h"
 #include <glm/vec2.hpp>
 #include <span>
 #include <vector>
 
 class TexturePacker {
 public:
-	using Position = glm::uvec2;
-	using Size = glm::uvec2;
+	using Position = TextureAbsCoord;
+	using Size = TextureAbsCoord;
 
 	struct Area {
 #ifndef __cpp_aggregate_paren_init
@@ -40,5 +41,5 @@ public:
 private:
 	std::span<const Image> inputImages;
 	std::vector<size_t> sortedIndexes;
-	unsigned int maxTextureSize;
+	GLsizei maxTextureSize;
 };
diff --git a/config/types.h b/config/types.h
new file mode 100644
index 0000000..a84be90
--- /dev/null
+++ b/config/types.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "glad/gl.h"
+#include <glm/geometric.hpp>
+
+using Distance = float;
+using Angle = float;
+
+template<glm::length_t D> using Position = glm::vec<D, Distance>;
+template<glm::length_t D> using Size = glm::vec<D, Distance>;
+template<glm::length_t D> using Scale = glm::vec<D, float>;
+template<glm::length_t D> using Direction = glm::vec<D, float>;
+template<glm::length_t D> using Normal = Direction<D>;
+template<glm::length_t D> using Rotation = glm::vec<D, Angle>;
+template<glm::length_t Channels> using Colour = glm::vec<Channels, float>;
+
+using Position2D = Position<2>;
+using Position3D = Position<3>;
+using Size2D = Size<2>;
+using Size3D = Size<3>;
+using Scale2D = Scale<2>;
+using Scale3D = Scale<3>;
+using Direction2D = Direction<2>;
+using Direction3D = Direction<3>;
+using Normal2D = Normal<2>;
+using Normal3D = Normal<3>;
+using Rotation2D = Rotation<2>;
+using Rotation3D = Rotation<3>;
+using TextureRelCoord = glm::vec<2, float>;
+using TextureAbsCoord = glm::vec<2, GLsizei>;
+using RGB = Colour<3>;
+using RGBA = Colour<4>;
+using ScreenRelCoord = glm::vec<2, float>;
+using ScreenAbsCoord = glm::vec<2, uint16_t>;
diff --git a/game/geoData.h b/game/geoData.h
index f9a7d7b..b3ec51d 100644
--- a/game/geoData.h
+++ b/game/geoData.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include <array>
 #include <filesystem>
 #include <glm/glm.hpp>
@@ -16,47 +17,47 @@ public:
 		float height {-1.5F};
 	};
 
-	using Quad = std::array<glm::vec3, 4>;
+	using Quad = std::array<Position3D, 4>;
 
-	using Limits = std::pair<glm::ivec2, glm::ivec2>;
+	using Limits = std::pair<glm::vec<2, int>, glm::vec<2, int>>;
 
 	explicit GeoData(Limits limit, float scale = 10.F);
 
 	void generateRandom();
 	void loadFromImages(const std::filesystem::path &, float scale);
 
-	[[nodiscard]] glm::vec3 positionAt(glm::vec2) const;
-	[[nodiscard]] std::optional<glm::vec3> intersectRay(const Ray &) const;
+	[[nodiscard]] Position3D positionAt(Position2D) const;
+	[[nodiscard]] std::optional<Position3D> intersectRay(const Ray &) const;
 
-	[[nodiscard]] unsigned int at(glm::ivec2) const;
+	[[nodiscard]] unsigned int at(glm::vec<2, int>) const;
 	[[nodiscard]] unsigned int at(int x, int y) const;
-	[[nodiscard]] Quad quad(glm::vec2) const;
+	[[nodiscard]] Quad quad(Position2D) const;
 
 	[[nodiscard]] Limits getLimit() const;
-	[[nodiscard]] glm::uvec2 getSize() const;
+	[[nodiscard]] glm::vec<2, unsigned int> getSize() const;
 	[[nodiscard]] float getScale() const;
 	[[nodiscard]] std::span<const Node> getNodes() const;
 
 	class RayTracer {
 	public:
-		RayTracer(glm::vec2 p0, glm::vec2 p1);
+		RayTracer(Position2D p0, Position2D p1);
 
-		glm::vec2 next();
+		Position2D next();
 
 	private:
-		RayTracer(glm::vec2 p0, glm::vec2 p1, glm::vec2 d);
-		RayTracer(glm::vec2 p0, glm::vec2 d, std::pair<float, float>, std::pair<float, float>);
-		static std::pair<float, float> byAxis(glm::vec2 p0, glm::vec2 p1, glm::vec2 d, glm::length_t);
+		RayTracer(Position2D p0, Position2D p1, Position2D d);
+		RayTracer(Position2D p0, Position2D d, std::pair<float, float>, std::pair<float, float>);
+		static std::pair<float, float> byAxis(Position2D p0, Position2D p1, Position2D d, glm::length_t);
 
-		glm::vec2 p;
-		const glm::vec2 d;
+		Position2D p;
+		const Position2D d;
 		float error;
-		glm::vec2 inc;
+		Position2D inc;
 	};
 
 protected:
 	Limits limit {}; // Base grid limits first(x,y) -> second(x,y)
-	glm::uvec2 size {};
+	glm::vec<2, unsigned> size {};
 	float scale {1};
 	std::vector<Node> nodes;
 };
diff --git a/game/network/link.h b/game/network/link.h
index 0d66c42..78d3e91 100644
--- a/game/network/link.h
+++ b/game/network/link.h
@@ -17,12 +17,12 @@ class Ray;
 // it has location
 class Node : public StdTypeDefs<Node> {
 public:
-	explicit Node(glm::vec3 p) noexcept : pos(p) {};
+	explicit Node(Position3D p) noexcept : pos(p) {};
 	virtual ~Node() noexcept = default;
 	NO_COPY(Node);
 	NO_MOVE(Node);
 
-	glm::vec3 pos;
+	Position3D pos;
 };
 
 // Generic network link
@@ -51,14 +51,14 @@ public:
 	float length;
 
 protected:
-	[[nodiscard]] virtual glm::vec3
+	[[nodiscard]] virtual Position3D
 	vehiclePositionOffset() const
 	{
 		return {};
 	}
 };
 
-bool operator<(const glm::vec3 & a, const glm::vec3 & b);
+bool operator<(const Position3D & a, const Position3D & b);
 bool operator<(const Node & a, const Node & b);
 
 class LinkStraight : public virtual Link {
@@ -77,14 +77,14 @@ LinkStraight::~LinkStraight() = default;
 class LinkCurve : public virtual Link {
 public:
 	inline ~LinkCurve() override = 0;
-	LinkCurve(glm::vec3, float, Arc);
+	LinkCurve(Position3D, float, Arc);
 	NO_COPY(LinkCurve);
 	NO_MOVE(LinkCurve);
 
 	[[nodiscard]] Location positionAt(float dist, unsigned char start) const override;
 	[[nodiscard]] bool intersectRay(const Ray &) const override;
 
-	glm::vec3 centreBase;
+	Position3D centreBase;
 	float radius;
 	Arc arc;
 };
diff --git a/game/network/network.h b/game/network/network.h
index b9316eb..02f8c30 100644
--- a/game/network/network.h
+++ b/game/network/network.h
@@ -26,32 +26,32 @@ public:
 	virtual ~Network() = default;
 	DEFAULT_MOVE_NO_COPY(Network);
 
-	[[nodiscard]] Node::Ptr findNodeAt(glm::vec3) const;
-	[[nodiscard]] Node::Ptr nodeAt(glm::vec3);
+	[[nodiscard]] Node::Ptr findNodeAt(Position3D) const;
+	[[nodiscard]] Node::Ptr nodeAt(Position3D);
 	enum class NodeIs { InNetwork, NotInNetwork };
 	using NodeInsertion = std::pair<Node::Ptr, NodeIs>;
-	[[nodiscard]] NodeInsertion newNodeAt(glm::vec3);
-	[[nodiscard]] NodeInsertion candidateNodeAt(glm::vec3) const;
+	[[nodiscard]] NodeInsertion newNodeAt(Position3D);
+	[[nodiscard]] NodeInsertion candidateNodeAt(Position3D) const;
 	[[nodiscard]] virtual Link::Ptr intersectRayLinks(const Ray &) const = 0;
 	[[nodiscard]] virtual Node::Ptr intersectRayNodes(const Ray &) const;
 
-	[[nodiscard]] Link::Nexts routeFromTo(const Link::End &, glm::vec3) const;
+	[[nodiscard]] Link::Nexts routeFromTo(const Link::End &, Position3D) const;
 	[[nodiscard]] Link::Nexts routeFromTo(const Link::End &, const Node::Ptr &) const;
 
-	virtual Link::CCollection candidateStraight(glm::vec3, glm::vec3) = 0;
-	virtual Link::CCollection candidateJoins(glm::vec3, glm::vec3) = 0;
-	virtual Link::CCollection candidateExtend(glm::vec3, glm::vec3) = 0;
-	virtual Link::CCollection addStraight(glm::vec3, glm::vec3) = 0;
-	virtual Link::CCollection addJoins(glm::vec3, glm::vec3) = 0;
-	virtual Link::CCollection addExtend(glm::vec3, glm::vec3) = 0;
+	virtual Link::CCollection candidateStraight(Position3D, Position3D) = 0;
+	virtual Link::CCollection candidateJoins(Position3D, Position3D) = 0;
+	virtual Link::CCollection candidateExtend(Position3D, Position3D) = 0;
+	virtual Link::CCollection addStraight(Position3D, Position3D) = 0;
+	virtual Link::CCollection addJoins(Position3D, Position3D) = 0;
+	virtual Link::CCollection addExtend(Position3D, Position3D) = 0;
 
 	[[nodiscard]] virtual float findNodeDirection(Node::AnyCPtr) const = 0;
 
 protected:
 	static void joinLinks(const Link::Ptr & l, const Link::Ptr & ol);
-	static GenCurveDef genCurveDef(const glm::vec3 & start, const glm::vec3 & end, float startDir);
+	static GenCurveDef genCurveDef(const Position3D & start, const Position3D & end, float startDir);
 	static std::pair<GenCurveDef, GenCurveDef> genCurveDef(
-			const glm::vec3 & start, const glm::vec3 & end, float startDir, float endDir);
+			const Position3D & start, const Position3D & end, float startDir, float endDir);
 
 	using Nodes = std::set<Node::Ptr, PtrMemberSorter<Node::Ptr, &Node::pos>>;
 	Nodes nodes;
@@ -71,7 +71,7 @@ protected:
 public:
 	template<typename L, typename... Params>
 	std::shared_ptr<L>
-	candidateLink(glm::vec3 a, glm::vec3 b, Params &&... params)
+	candidateLink(Position3D a, Position3D b, Params &&... params)
 		requires std::is_base_of_v<T, L>
 	{
 		const auto node1 = candidateNodeAt(a).first, node2 = candidateNodeAt(b).first;
@@ -80,7 +80,7 @@ public:
 
 	template<typename L, typename... Params>
 	std::shared_ptr<L>
-	addLink(glm::vec3 a, glm::vec3 b, Params &&... params)
+	addLink(Position3D a, Position3D b, Params &&... params)
 		requires std::is_base_of_v<T, L>
 	{
 		const auto node1 = nodeAt(a), node2 = nodeAt(b);
@@ -89,12 +89,12 @@ public:
 		return l;
 	}
 
-	Link::CCollection candidateStraight(glm::vec3 n1, glm::vec3 n2) override;
-	Link::CCollection candidateJoins(glm::vec3, glm::vec3) override;
-	Link::CCollection candidateExtend(glm::vec3, glm::vec3) override;
-	Link::CCollection addStraight(glm::vec3 n1, glm::vec3 n2) override;
-	Link::CCollection addJoins(glm::vec3, glm::vec3) override;
-	Link::CCollection addExtend(glm::vec3, glm::vec3) override;
+	Link::CCollection candidateStraight(Position3D n1, Position3D n2) override;
+	Link::CCollection candidateJoins(Position3D, Position3D) override;
+	Link::CCollection candidateExtend(Position3D, Position3D) override;
+	Link::CCollection addStraight(Position3D n1, Position3D n2) override;
+	Link::CCollection addJoins(Position3D, Position3D) override;
+	Link::CCollection addExtend(Position3D, Position3D) override;
 
 	[[nodiscard]] float findNodeDirection(Node::AnyCPtr) const override;
 
diff --git a/game/network/network.impl.h b/game/network/network.impl.h
index 045335f..8e9e85c 100644
--- a/game/network/network.impl.h
+++ b/game/network/network.impl.h
@@ -54,14 +54,14 @@ NetworkOf<T>::findNodeDirection(Node::AnyCPtr n) const
 
 template<typename T>
 Link::CCollection
-NetworkOf<T>::candidateStraight(glm::vec3 n1, glm::vec3 n2)
+NetworkOf<T>::candidateStraight(Position3D n1, Position3D n2)
 {
 	return {candidateLink<typename T::StraightLink>(n1, n2)};
 }
 
 template<typename T>
 Link::CCollection
-NetworkOf<T>::candidateJoins(glm::vec3 start, glm::vec3 end)
+NetworkOf<T>::candidateJoins(Position3D start, Position3D end)
 {
 	if (glm::distance(start, end) < 2.F) {
 		return {};
@@ -75,7 +75,7 @@ NetworkOf<T>::candidateJoins(glm::vec3 start, glm::vec3 end)
 
 template<typename T>
 Link::CCollection
-NetworkOf<T>::candidateExtend(glm::vec3 start, glm::vec3 end)
+NetworkOf<T>::candidateExtend(Position3D start, Position3D end)
 {
 	const auto [cstart, cend, centre] = genCurveDef(start, end, findNodeDirection(candidateNodeAt(start).first));
 	return {candidateLink<typename T::CurveLink>(cstart, cend, centre)};
@@ -83,14 +83,14 @@ NetworkOf<T>::candidateExtend(glm::vec3 start, glm::vec3 end)
 
 template<typename T>
 Link::CCollection
-NetworkOf<T>::addStraight(glm::vec3 n1, glm::vec3 n2)
+NetworkOf<T>::addStraight(Position3D n1, Position3D n2)
 {
 	return {addLink<typename T::StraightLink>(n1, n2)};
 }
 
 template<typename T>
 Link::CCollection
-NetworkOf<T>::addJoins(glm::vec3 start, glm::vec3 end)
+NetworkOf<T>::addJoins(Position3D start, Position3D end)
 {
 	if (glm::distance(start, end) < 2.F) {
 		return {};
@@ -103,7 +103,7 @@ NetworkOf<T>::addJoins(glm::vec3 start, glm::vec3 end)
 
 template<typename T>
 Link::CCollection
-NetworkOf<T>::addExtend(glm::vec3 start, glm::vec3 end)
+NetworkOf<T>::addExtend(Position3D start, Position3D end)
 {
 	const auto [cstart, cend, centre] = genCurveDef(start, end, findNodeDirection(nodeAt(start)));
 	return {addLink<typename T::CurveLink>(cstart, cend, centre)};
diff --git a/game/network/rail.h b/game/network/rail.h
index 6684801..4a1932f 100644
--- a/game/network/rail.h
+++ b/game/network/rail.h
@@ -32,7 +32,7 @@ public:
 	NO_MOVE(RailLink);
 
 protected:
-	[[nodiscard]] glm::vec3 vehiclePositionOffset() const override;
+	[[nodiscard]] Position3D vehiclePositionOffset() const override;
 	[[nodiscard]] static Mesh::Ptr defaultMesh(const std::span<Vertex> vertices);
 
 	Mesh::Ptr mesh;
@@ -45,22 +45,22 @@ public:
 	RailLinkStraight(const Node::Ptr &, const Node::Ptr &);
 
 private:
-	RailLinkStraight(Node::Ptr, Node::Ptr, const glm::vec3 & diff);
+	RailLinkStraight(Node::Ptr, Node::Ptr, const Position3D & diff);
 };
 
 class RailLinkCurve : public RailLink, public LinkCurve {
 public:
-	RailLinkCurve(const Node::Ptr &, const Node::Ptr &, glm::vec2);
+	RailLinkCurve(const Node::Ptr &, const Node::Ptr &, Position2D);
 
 private:
-	RailLinkCurve(const Node::Ptr &, const Node::Ptr &, glm::vec3, const Arc);
+	RailLinkCurve(const Node::Ptr &, const Node::Ptr &, Position3D, const Arc);
 };
 
 class RailLinks : public NetworkOf<RailLink>, public WorldObject {
 public:
 	RailLinks();
 
-	std::shared_ptr<RailLink> addLinksBetween(glm::vec3 start, glm::vec3 end);
+	std::shared_ptr<RailLink> addLinksBetween(Position3D start, Position3D end);
 
 private:
 	void tick(TickDuration elapsed) override;
diff --git a/game/selectable.h b/game/selectable.h
index 31287d8..9732dca 100644
--- a/game/selectable.h
+++ b/game/selectable.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include <glm/glm.hpp>
 #include <special_members.h>
 
@@ -11,5 +12,5 @@ public:
 	virtual ~Selectable() = default;
 	DEFAULT_MOVE_COPY(Selectable);
 
-	[[nodiscard]] virtual bool intersectRay(const Ray &, glm::vec2 *, float *) const = 0;
+	[[nodiscard]] virtual bool intersectRay(const Ray &, Position2D *, float *) const = 0;
 };
diff --git a/game/vehicles/railVehicle.h b/game/vehicles/railVehicle.h
index be88142..e034852 100644
--- a/game/vehicles/railVehicle.h
+++ b/game/vehicles/railVehicle.h
@@ -17,7 +17,7 @@ public:
 
 	void move(const Train *, float & trailBy);
 
-	[[nodiscard]] bool intersectRay(const Ray &, glm::vec2 *, float *) const override;
+	[[nodiscard]] bool intersectRay(const Ray &, Position2D *, float *) const override;
 
 	RailVehicleClassPtr rvClass;
 	using LV = RailVehicleClass::LocationVertex;
diff --git a/game/vehicles/train.h b/game/vehicles/train.h
index 20c3bc4..7f0bb99 100644
--- a/game/vehicles/train.h
+++ b/game/vehicles/train.h
@@ -27,7 +27,7 @@ public:
 		return objects.front()->location;
 	}
 
-	[[nodiscard]] bool intersectRay(const Ray &, glm::vec2 *, float *) const override;
+	[[nodiscard]] bool intersectRay(const Ray &, Position2D *, float *) const override;
 
 	void tick(TickDuration elapsed) override;
 	void doActivity(Go *, TickDuration) override;
diff --git a/gfx/gl/bufferedLocation.h b/gfx/gl/bufferedLocation.h
index 8096489..39d3139 100644
--- a/gfx/gl/bufferedLocation.h
+++ b/gfx/gl/bufferedLocation.h
@@ -8,7 +8,7 @@
 
 class BufferedLocation {
 public:
-	BufferedLocation(glm::vec3 = {}, glm::vec3 = {});
+	BufferedLocation(Position3D = {}, Rotation3D = {});
 	BufferedLocation(const Location &);
 	virtual ~BufferedLocation() = default;
 
@@ -16,13 +16,13 @@ public:
 
 	operator const Location &() const;
 
-	glm::vec3 position() const;
-	glm::vec3 rotation() const;
-	void setPosition(glm::vec3, bool update = true);
-	void setRotation(glm::vec3, bool update = true);
-	void setLocation(glm::vec3, glm::vec3);
+	[[nodiscard]] Position3D position() const;
+	[[nodiscard]] Rotation3D rotation() const;
+	void setPosition(Position3D, bool update = true);
+	void setRotation(Rotation3D, bool update = true);
+	void setLocation(Position3D, Rotation3D);
 
-	glm::mat4 getTransform() const;
+	[[nodiscard]] glm::mat4 getTransform() const;
 
 private:
 	virtual void updateBuffer() = 0;
diff --git a/gfx/gl/camera.cpp b/gfx/gl/camera.cpp
index c4c9544..80feab4 100644
--- a/gfx/gl/camera.cpp
+++ b/gfx/gl/camera.cpp
@@ -5,7 +5,7 @@
 #include <maths.h>
 #include <ray.h>
 
-Camera::Camera(glm::vec3 pos, float fov, float aspect, float zNear, float zFar) :
+Camera::Camera(Position3D pos, Angle fov, Angle aspect, Distance zNear, Distance zFar) :
 	position {pos}, forward {::north}, up {::up}, near {zNear}, far {zFar},
 	projection {glm::perspective(fov, aspect, zNear, zFar)},
 	viewProjection {projection * glm::lookAt(position, position + forward, up)},
@@ -14,7 +14,7 @@ Camera::Camera(glm::vec3 pos, float fov, float aspect, float zNear, float zFar)
 }
 
 Ray
-Camera::unProject(const glm::vec2 & mouse) const
+Camera::unProject(const ScreenRelCoord & mouse) const
 {
 	static constexpr const glm::vec4 screen {0, 0, 1, 1};
 	const auto mouseProjection = glm::lookAt(::origin, forward, up);
diff --git a/gfx/gl/camera.h b/gfx/gl/camera.h
index 7956ec3..469df0d 100644
--- a/gfx/gl/camera.h
+++ b/gfx/gl/camera.h
@@ -1,12 +1,13 @@
 #pragma once
 
+#include "config/types.h"
 #include <glm/glm.hpp>
 #include <maths.h>
 #include <ray.h>
 
 class Camera {
 public:
-	Camera(glm::vec3 pos, float fov, float aspect, float zNear, float zFar);
+	Camera(Position3D, Angle fov, Angle aspect, Distance zNear, Distance zFar);
 
 	[[nodiscard]] glm::mat4
 	getViewProjection() const
@@ -14,23 +15,23 @@ public:
 		return viewProjection;
 	}
 
-	[[nodiscard]] Ray unProject(const glm::vec2 &) const;
+	[[nodiscard]] Ray unProject(const ScreenRelCoord &) const;
 
 	void
-	setPosition(const glm::vec3 & p)
+	setPosition(const Position3D & p)
 	{
 		position = p;
 		updateView();
 	}
 
 	void
-	setForward(const glm::vec3 & f)
+	setForward(const Direction3D & f)
 	{
 		setForward(f, upFromForward(f));
 	}
 
 	void
-	setForward(const glm::vec3 & f, const glm::vec3 & u)
+	setForward(const Direction3D & f, const Direction3D & u)
 	{
 		forward = f;
 		up = u;
@@ -38,21 +39,21 @@ public:
 	}
 
 	void
-	setView(const glm::vec3 & p, const glm::vec3 & f)
+	setView(const Position3D & p, const Direction3D & f)
 	{
 		position = p;
 		setForward(f);
 	}
 
 	void
-	setView(const glm::vec3 & p, const glm::vec3 & f, const glm::vec3 & u)
+	setView(const Position3D & p, const Direction3D & f, const Direction3D & u)
 	{
 		position = p;
 		setView(f, u);
 	}
 
 	void
-	lookAt(const glm::vec3 & target)
+	lookAt(const Position3D & target)
 	{
 		setForward(glm::normalize(target - position));
 	}
@@ -71,14 +72,14 @@ public:
 
 	[[nodiscard]] std::array<glm::vec4, 4> extentsAtDist(float) const;
 
-	[[nodiscard]] static glm::vec3 upFromForward(const glm::vec3 & forward);
+	[[nodiscard]] static Direction3D upFromForward(const Direction3D & forward);
 
 private:
 	void updateView();
 
-	glm::vec3 position;
-	glm::vec3 forward;
-	glm::vec3 up;
+	Position3D position;
+	Direction3D forward;
+	Direction3D up;
 
 	float near, far;
 	glm::mat4 projection;
diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index 5799daf..218cf6d 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -14,7 +14,7 @@ static constexpr const std::array<const glm::i8vec4, 4> displayVAOdata {{
 		{1, -1, 1, 0},
 }};
 
-SceneRenderer::SceneRenderer(glm::ivec2 s, GLuint o) :
+SceneRenderer::SceneRenderer(ScreenAbsCoord s, GLuint o) :
 	camera {{-1250.0F, -1250.0F, 35.0F}, quarter_pi, ratio(s), 0.1F, 10000.0F}, size {s}, output {o},
 	lighting {lighting_vs, lighting_fs}, shadowMapper {{2048, 2048}}
 {
diff --git a/gfx/gl/sceneRenderer.h b/gfx/gl/sceneRenderer.h
index 55df84d..87f474b 100644
--- a/gfx/gl/sceneRenderer.h
+++ b/gfx/gl/sceneRenderer.h
@@ -11,18 +11,18 @@
 
 class SceneRenderer {
 public:
-	explicit SceneRenderer(glm::ivec2 size, GLuint output);
+	explicit SceneRenderer(ScreenAbsCoord size, GLuint output);
 
 	void render(const SceneProvider &) const;
-	void setAmbientLight(const glm::vec3 & colour) const;
-	void setDirectionalLight(const glm::vec3 & colour, const glm::vec3 & direction, const SceneProvider &) const;
+	void setAmbientLight(const RGB & colour) const;
+	void setDirectionalLight(const RGB & colour, const Direction3D & direction, const SceneProvider &) const;
 
 	Camera camera;
 
 private:
 	void renderQuad() const;
 
-	glm::ivec2 size;
+	ScreenAbsCoord size;
 	GLuint output;
 	glFrameBuffer gBuffer;
 	glTexture gPosition, gNormal, gAlbedoSpec, gIllumination;
@@ -39,7 +39,7 @@ private:
 		DirectionalLightProgram();
 		using Program::use;
 
-		void setDirectionalLight(const glm::vec3 &, const glm::vec3 &, const std::span<const glm::mat4x4>,
+		void setDirectionalLight(const RGB &, const Direction3D &, const std::span<const glm::mat4x4>,
 				const std::span<const glm::vec4>, std::size_t maps) const;
 
 	private:
diff --git a/gfx/gl/sceneShader.h b/gfx/gl/sceneShader.h
index ead184e..d1c6ef2 100644
--- a/gfx/gl/sceneShader.h
+++ b/gfx/gl/sceneShader.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include "program.h"
 #include <glArrays.h>
 
@@ -52,7 +53,7 @@ class SceneShader {
 	public:
 		PointLightShader();
 
-		void add(const glm::vec3 & position, const glm::vec3 & colour, const float kq) const;
+		void add(const Position3D & position, const RGB & colour, const float kq) const;
 
 	private:
 		UniformLocation colourLoc;
@@ -65,7 +66,7 @@ class SceneShader {
 	public:
 		SpotLightShader();
 
-		void add(const glm::vec3 & position, const glm::vec3 & direction, const glm::vec3 & colour, const float kq,
+		void add(const Position3D & position, const Direction3D & direction, const RGB & colour, const float kq,
 				const float arc) const;
 
 	private:
diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 79b39c0..58f65c4 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -15,7 +15,7 @@
 #include <tuple>
 #include <vector>
 
-ShadowMapper::ShadowMapper(const glm::ivec2 & s) :
+ShadowMapper::ShadowMapper(const TextureAbsCoord & s) :
 	fixedPoint {shadowFixedPoint_vs}, dynamicPointInst {shadowDynamicPointInst_vs}, size {s}
 {
 	glBindTexture(GL_TEXTURE_2D, depthMap);
diff --git a/gfx/gl/shadowMapper.h b/gfx/gl/shadowMapper.h
index cd1b975..e5272a3 100644
--- a/gfx/gl/shadowMapper.h
+++ b/gfx/gl/shadowMapper.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include "lib/glArrays.h"
 #include "program.h"
 #include <glm/vec2.hpp>
@@ -11,7 +12,7 @@ class Camera;
 
 class ShadowMapper {
 public:
-	explicit ShadowMapper(const glm::ivec2 & size);
+	explicit ShadowMapper(const TextureAbsCoord & size);
 
 	static constexpr std::size_t SHADOW_BANDS {4};
 
@@ -21,7 +22,7 @@ public:
 		size_t maps {};
 	};
 
-	[[nodiscard]] Definitions update(const SceneProvider &, const glm::vec3 & direction, const Camera &) const;
+	[[nodiscard]] Definitions update(const SceneProvider &, const Direction3D & direction, const Camera &) const;
 
 	class FixedPoint : public Program {
 	public:
@@ -55,9 +56,9 @@ public:
 	}
 
 private:
-	[[nodiscard]] static std::vector<std::array<glm::vec3, 4>> getBandViewExtents(
+	[[nodiscard]] static std::vector<std::array<Position3D, 4>> getBandViewExtents(
 			const Camera &, const glm::mat4 & lightView);
 	glFrameBuffer depthMapFBO;
 	glTexture depthMap;
-	glm::ivec2 size;
+	TextureAbsCoord size;
 };
diff --git a/gfx/gl/uiShader.h b/gfx/gl/uiShader.h
index 2766af8..362e90c 100644
--- a/gfx/gl/uiShader.h
+++ b/gfx/gl/uiShader.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include "program.h"
 #include <cstddef>
 #include <glad/gl.h>
@@ -33,7 +34,7 @@ private:
 	class TextProgram : public UIProgram {
 	public:
 		explicit TextProgram(const glm::mat4 & vp);
-		void use(const glm::vec3 & colour) const;
+		void use(const RGB & colour) const;
 
 	private:
 		RequiredUniformLocation colorLoc;
diff --git a/gfx/models/texture.cpp b/gfx/models/texture.cpp
index b7f1bee..f60d158 100644
--- a/gfx/models/texture.cpp
+++ b/gfx/models/texture.cpp
@@ -1,4 +1,5 @@
 #include "texture.h"
+#include "config/types.h"
 #include "glArrays.h"
 #include "tga.h"
 #include <cache.h>
diff --git a/gfx/models/texture.h b/gfx/models/texture.h
index 1b66c64..5e1b440 100644
--- a/gfx/models/texture.h
+++ b/gfx/models/texture.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include <cache.h>
 #include <filesystem>
 #include <glArrays.h>
@@ -42,7 +43,7 @@ public:
 
 protected:
 	static void save(const glTexture &, GLenum, GLenum, uint8_t channels, const char * path, uint8_t tgaFormat);
-	static glm::ivec2 getSize(const glTexture &);
+	static TextureAbsCoord getSize(const glTexture &);
 
 	glTexture m_texture;
 	GLenum type;
@@ -53,7 +54,7 @@ public:
 	TextureAtlas(GLsizei width, GLsizei height, GLuint count);
 
 	void bind(GLenum unit = GL_TEXTURE0) const override;
-	GLuint add(glm::ivec2 position, glm::ivec2 size, void * data, TextureOptions = {});
+	GLuint add(TextureAbsCoord position, TextureAbsCoord size, void * data, TextureOptions = {});
 
 private:
 	glTexture m_atlas;
diff --git a/gfx/models/tga.h b/gfx/models/tga.h
index 52db220..3d072fb 100644
--- a/gfx/models/tga.h
+++ b/gfx/models/tga.h
@@ -4,10 +4,11 @@
 #include <glm/vec2.hpp>
 
 struct TGAHead {
+	using XY = glm::vec<2, uint16_t>;
 	uint8_t idLength {}, colorMapType {}, format {};
 	uint16_t __attribute__((packed)) colorMapFirst {}, colorMapLength {};
 	uint8_t colorMapEntrySize {};
-	glm::vec<2, uint16_t> origin {}, size {};
+	XY origin {}, size {};
 	uint8_t pixelDepth {};
 	uint8_t descriptor {};
 };
diff --git a/gfx/models/vertex.h b/gfx/models/vertex.h
index 0464ea7..5635fa1 100644
--- a/gfx/models/vertex.h
+++ b/gfx/models/vertex.h
@@ -1,12 +1,12 @@
 #pragma once
 
+#include "config/types.h"
 #include <glad/gl.h>
-#include <glm/glm.hpp>
 
 class Vertex {
 public:
 #ifndef __cpp_aggregate_paren_init
-	constexpr Vertex(glm::vec3 pos, glm::vec2 texCoord, glm::vec3 normal, glm::vec4 colour = {}, GLuint material = 0) :
+	constexpr Vertex(Position3D pos, TextureRelCoord texCoord, Normal3D normal, RGBA colour = {}, GLuint material = 0) :
 		pos {std::move(pos)}, texCoord {std::move(texCoord)}, normal {std::move(normal)}, colour {std::move(colour)},
 		material {material}
 	{
@@ -15,9 +15,9 @@ public:
 
 	bool operator==(const Vertex &) const = default;
 
-	glm::vec3 pos;
-	glm::vec2 texCoord;
-	glm::vec3 normal;
-	glm::vec4 colour {};
+	Position3D pos {};
+	TextureRelCoord texCoord {};
+	Normal3D normal {};
+	RGBA colour {};
 	GLuint material {};
 };
diff --git a/lib/geometricPlane.h b/lib/geometricPlane.h
index dc8df50..c74beff 100644
--- a/lib/geometricPlane.h
+++ b/lib/geometricPlane.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include <glm/vec3.hpp>
 #include <optional>
 
@@ -9,14 +10,15 @@ class GeometricPlane {
 public:
 	struct DistAndPosition {
 		float dist;
-		glm::vec3 position;
+		Position3D position;
 	};
 	enum class PlaneRelation { Above, Below, On };
 
-	glm::vec3 origin, normal;
+	Position3D origin;
+	Normal3D normal;
 
-	PlaneRelation getRelation(glm::vec3 point) const;
-	std::optional<DistAndPosition> getRayIntersectPosition(const Ray &) const;
+	[[nodiscard]] PlaneRelation getRelation(Position3D point) const;
+	[[nodiscard]] std::optional<DistAndPosition> getRayIntersectPosition(const Ray &) const;
 
 	static bool isIntersect(PlaneRelation a, PlaneRelation b);
 };
diff --git a/lib/location.h b/lib/location.h
index 078f5d3..7f2b44d 100644
--- a/lib/location.h
+++ b/lib/location.h
@@ -1,14 +1,16 @@
 #pragma once
 
+#include "config/types.h"
 #include <glm/mat4x4.hpp>
-#include <glm/vec3.hpp>
 
 class Location {
 public:
-	explicit Location(glm::vec3 pos = {}, glm::vec3 rot = {}) : pos {pos}, rot {rot} { }
+#ifndef __cpp_aggregate_paren_init
+	explicit Location(Position3D pos = {}, Rotation3D rot = {}) : pos {pos}, rot {rot} { }
+#endif
 
-	glm::mat4 getTransform() const;
+	[[nodiscard]] glm::mat4 getTransform() const;
 
-	glm::vec3 pos;
-	glm::vec3 rot;
+	Position3D pos;
+	Rotation3D rot;
 };
diff --git a/lib/maths.h b/lib/maths.h
index b95b706..67b2a15 100644
--- a/lib/maths.h
+++ b/lib/maths.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include <cmath>
 #include <glm/glm.hpp>
 #include <glm/gtc/constants.hpp>
@@ -9,7 +10,7 @@
 struct Arc : public std::pair<float, float> {
 	using std::pair<float, float>::pair;
 
-	Arc(const glm::vec3 & centre3, const glm::vec3 & e0p, const glm::vec3 & e1p);
+	Arc(const Position3D & centre3, const Position3D & e0p, const Position3D & e1p);
 
 	float
 	operator[](unsigned int i) const
@@ -18,19 +19,19 @@ struct Arc : public std::pair<float, float> {
 	}
 };
 
-constexpr const glm::vec3 origin {0, 0, 0};
-constexpr const glm::vec3 up {0, 0, 1};
-constexpr const glm::vec3 down {0, 0, -1};
-constexpr const glm::vec3 north {0, 1, 0};
-constexpr const glm::vec3 south {0, -1, 0};
-constexpr const glm::vec3 east {1, 0, 0};
-constexpr const glm::vec3 west {-1, 0, 0};
+constexpr const Position3D origin {0, 0, 0};
+constexpr const Position3D up {0, 0, 1};
+constexpr const Position3D down {0, 0, -1};
+constexpr const Position3D north {0, 1, 0};
+constexpr const Position3D south {0, -1, 0};
+constexpr const Position3D east {1, 0, 0};
+constexpr const Position3D west {-1, 0, 0};
 constexpr auto half_pi {glm::half_pi<float>()};
 constexpr auto quarter_pi {half_pi / 2};
 constexpr auto pi {glm::pi<float>()};
 constexpr auto two_pi {glm::two_pi<float>()};
 
-glm::mat4 flat_orientation(const glm::vec3 & diff);
+glm::mat4 flat_orientation(const Rotation3D & diff);
 
 // C++ wrapper for C's sincosf, but with references, not pointers
 inline auto
@@ -39,10 +40,10 @@ sincosf(float a, float & s, float & c)
 	return sincosf(a, &s, &c);
 }
 
-inline glm::vec2
+inline Rotation2D
 sincosf(float a)
 {
-	glm::vec2 sc;
+	Rotation2D sc;
 	sincosf(a, sc.x, sc.y);
 	return sc;
 }
@@ -51,11 +52,11 @@ glm::mat2 rotate_flat(float);
 glm::mat4 rotate_roll(float);
 glm::mat4 rotate_yaw(float);
 glm::mat4 rotate_pitch(float);
-glm::mat4 rotate_yp(glm::vec2);
-glm::mat4 rotate_ypr(glm::vec3);
+glm::mat4 rotate_yp(Rotation2D);
+glm::mat4 rotate_ypr(Rotation3D);
 
-float vector_yaw(const glm::vec3 & diff);
-float vector_pitch(const glm::vec3 & diff);
+float vector_yaw(const Direction3D & diff);
+float vector_pitch(const Direction3D & diff);
 
 float round_frac(const float & v, const float & frac);
 
@@ -87,26 +88,26 @@ perspective_divide(glm::vec<4, T, Q> v)
 	return v / v.w;
 }
 
-constexpr inline glm::vec2
-operator!(const glm::vec3 & v)
+constexpr inline Position2D
+operator!(const Position3D & v)
 {
 	return {v.x, v.y};
 }
 
-constexpr inline glm::vec3
-operator^(const glm::vec2 & v, float z)
+constexpr inline Position3D
+operator^(const Position2D & v, float z)
 {
 	return {v.x, v.y, z};
 }
 
 constexpr inline glm::vec4
-operator^(const glm::vec3 & v, float w)
+operator^(const Position3D & v, float w)
 {
 	return {v.x, v.y, v.z, w};
 }
 
-constexpr inline glm::vec3
-operator!(const glm::vec2 & v)
+constexpr inline Position3D
+operator!(const Position2D & v)
 {
 	return v ^ 0.F;
 }
@@ -125,15 +126,15 @@ operator||(const glm::vec<L, T, Q> v1, const T v2)
 	return {v1, v2};
 }
 
-inline glm::vec3
-operator%(const glm::vec3 & p, const glm::mat4 & mutation)
+inline Position3D
+operator%(const Position3D & p, const glm::mat4 & mutation)
 {
 	const auto p2 = mutation * (p ^ 1);
 	return p2 / p2.w;
 }
 
-inline glm::vec3
-operator%=(glm::vec3 & p, const glm::mat4 & mutation)
+inline Position3D
+operator%=(Position3D & p, const glm::mat4 & mutation)
 {
 	return p = p % mutation;
 }
@@ -146,10 +147,10 @@ arc_length(const Arc & arc)
 
 float normalize(float ang);
 
-std::pair<glm::vec2, bool> find_arc_centre(glm::vec2 start, float entrys, glm::vec2 end, float entrye);
-std::pair<glm::vec2, bool> find_arc_centre(glm::vec2 start, glm::vec2 ad, glm::vec2 end, glm::vec2 bd);
-std::pair<float, float> find_arcs_radius(glm::vec2 start, float entrys, glm::vec2 end, float entrye);
-float find_arcs_radius(glm::vec2 start, glm::vec2 ad, glm::vec2 end, glm::vec2 bd);
+std::pair<Position2D, bool> find_arc_centre(Position2D start, float entrys, Position2D end, float entrye);
+std::pair<Position2D, bool> find_arc_centre(Position2D start, Position2D ad, Position2D end, Position2D bd);
+std::pair<float, float> find_arcs_radius(Position2D start, float entrys, Position2D end, float entrye);
+float find_arcs_radius(Position2D start, Position2D ad, Position2D end, Position2D bd);
 
 template<typename T>
 auto
diff --git a/lib/ray.h b/lib/ray.h
index 9bf47af..bc70c74 100644
--- a/lib/ray.h
+++ b/lib/ray.h
@@ -1,17 +1,20 @@
 #pragma once
 
+#include "config/types.h"
 #include <glm/glm.hpp>
 #include <span>
 
 class Ray {
 public:
-	Ray(glm::vec3 start, glm::vec3 direction) : start {start}, direction {direction} { }
+#ifndef __cpp_aggregate_paren_init
+	Ray(Position3D start, Direction3D direction) : start {start}, direction {direction} { }
+#endif
 
-	static Ray fromPoints(glm::vec3, glm::vec3);
+	static Ray fromPoints(Position3D, Position3D);
 
-	glm::vec3 start;
-	glm::vec3 direction;
+	Position3D start;
+	Direction3D direction;
 
-	float distanceToLine(const glm::vec3 & a, const glm::vec3 & b) const;
-	bool passesCloseToEdges(const std::span<const glm::vec3> positions, float distance) const;
+	[[nodiscard]] float distanceToLine(const Position3D & a, const Position3D & b) const;
+	[[nodiscard]] bool passesCloseToEdges(const std::span<const Position3D> positions, float distance) const;
 };
diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 145481e..177ab6a 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -183,14 +183,15 @@ BOOST_AUTO_TEST_CASE(texturePacker_many, *boost::unit_test::timeout(5))
 {
 	std::vector<TexturePacker::Image> images(256);
 	std::fill(images.begin(), images.end(), TexturePacker::Image {32, 32});
-	const auto totalSize = std::accumulate(images.begin(), images.end(), 0U, [](auto t, const auto & i) {
+	const auto totalSize = std::accumulate(images.begin(), images.end(), 0, [](auto t, const auto & i) {
 		return t + TexturePacker::area(i);
 	});
 	TexturePacker tp {images};
 	BOOST_CHECK_EQUAL(TexturePacker::Size(32, 32), tp.minSize());
 	const auto result = tp.pack();
 	BOOST_CHECK_EQUAL(result.first.size(), images.size());
-	BOOST_CHECK_GE(TexturePacker::area(result.second), TexturePacker::area(images.front()) * images.size());
+	BOOST_CHECK_GE(TexturePacker::area(result.second),
+			TexturePacker::area(images.front()) * static_cast<GLsizei>(images.size()));
 	BOOST_CHECK_EQUAL(totalSize, TexturePacker::area(result.second));
 }
 
diff --git a/test/testRenderOutput.h b/test/testRenderOutput.h
index 13c380f..056d029 100644
--- a/test/testRenderOutput.h
+++ b/test/testRenderOutput.h
@@ -1,24 +1,25 @@
 #pragma once
 
+#include "config/types.h"
 #include "glArrays.h"
 #include <glm/vec2.hpp>
 #include <special_members.h>
 
 class TestRenderOutput {
 public:
-	TestRenderOutput(glm::ivec2 size = {640, 480});
+	explicit TestRenderOutput(TextureAbsCoord size = {640, 480});
 	virtual ~TestRenderOutput() = default;
 
 	NO_MOVE(TestRenderOutput);
 	NO_COPY(TestRenderOutput);
 
-	const glm::ivec2 size;
+	const TextureAbsCoord size;
 	glFrameBuffer output;
 	glRenderBuffer depth;
 	glTexture outImage;
 };
 
-template<glm::ivec2 Size> class TestRenderOutputSize : public TestRenderOutput {
+template<TextureAbsCoord Size> class TestRenderOutputSize : public TestRenderOutput {
 public:
 	TestRenderOutputSize() : TestRenderOutput {Size} { }
 };
diff --git a/test/testStructures.h b/test/testStructures.h
index 6966052..aaaf940 100644
--- a/test/testStructures.h
+++ b/test/testStructures.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include <persistence.h>
 
 struct AbsObject : public Persistence::Persistable {
@@ -31,9 +32,9 @@ struct TestObject : public Persistence::Persistable {
 	float flt {};
 	std::string str {};
 	bool bl {};
-	glm::vec3 pos {};
+	Position3D pos {};
 	std::vector<float> flts;
-	std::vector<glm::vec3> poss;
+	std::vector<Position3D> poss;
 	std::vector<std::vector<std::vector<std::string>>> nest;
 	std::unique_ptr<TestObject> ptr;
 	std::unique_ptr<AbsObject> aptr;
diff --git a/ui/builders/freeExtend.h b/ui/builders/freeExtend.h
index 55fe7ff..b276426 100644
--- a/ui/builders/freeExtend.h
+++ b/ui/builders/freeExtend.h
@@ -9,5 +9,5 @@ class BuilderFreeExtend : public EditNetwork::Builder {
 	void click(Network * network, const GeoData * geoData, const SDL_MouseButtonEvent & e, const Ray & ray) override;
 	void move(Network * network, const GeoData * geoData, const SDL_MouseMotionEvent & e, const Ray & ray) override;
 
-	std::optional<glm::vec3> p1;
+	std::optional<Position3D> p1;
 };
diff --git a/ui/builders/straight.h b/ui/builders/straight.h
index 1cde2b0..cf99a1d 100644
--- a/ui/builders/straight.h
+++ b/ui/builders/straight.h
@@ -9,7 +9,7 @@ class BuilderStraight : public EditNetwork::Builder {
 	void click(Network * network, const GeoData * geoData, const SDL_MouseButtonEvent & e, const Ray & ray) override;
 	void move(Network * network, const GeoData * geoData, const SDL_MouseMotionEvent & e, const Ray & ray) override;
 
-	void create(Network * network, glm::vec3 p1, glm::vec3 p2) const;
+	void create(Network * network, Position3D p1, Position3D p2) const;
 
-	std::optional<glm::vec3> p1;
+	std::optional<Position3D> p1;
 };
diff --git a/ui/gameMainSelector.cpp b/ui/gameMainSelector.cpp
index 6c6935c..808e0e4 100644
--- a/ui/gameMainSelector.cpp
+++ b/ui/gameMainSelector.cpp
@@ -14,7 +14,7 @@
 #include <typeinfo>
 #include <vector>
 
-GameMainSelector::GameMainSelector(const Camera * c, glm::vec2 size) : UIComponent {{{}, size}}, camera {c} { }
+GameMainSelector::GameMainSelector(const Camera * c, ScreenAbsCoord size) : UIComponent {{{}, size}}, camera {c} { }
 
 constexpr glm::vec2 TargetPos {5, 45};
 
diff --git a/ui/gameMainSelector.h b/ui/gameMainSelector.h
index 98cdf53..88db34b 100644
--- a/ui/gameMainSelector.h
+++ b/ui/gameMainSelector.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "SDL_events.h"
+#include "config/types.h"
 #include "special_members.h"
 #include "uiComponent.h"
 #include "worldOverlay.h"
@@ -26,7 +27,7 @@ public:
 		virtual void render(const SceneShader &) const;
 	};
 
-	GameMainSelector(const Camera * c, glm::vec2 size);
+	GameMainSelector(const Camera * c, ScreenAbsCoord size);
 
 	void render(const UIShader & shader, const Position & pos) const override;
 	void render(const SceneShader & shader) const override;
diff --git a/ui/manualCameraController.h b/ui/manualCameraController.h
index d15fa76..46655bc 100644
--- a/ui/manualCameraController.h
+++ b/ui/manualCameraController.h
@@ -11,7 +11,7 @@ class Camera;
 
 class ManualCameraController : public CameraController, public UIComponent {
 public:
-	explicit ManualCameraController(glm::vec2 f) : UIComponent {{}}, focus {f} { }
+	explicit ManualCameraController(Position2D f) : UIComponent {{}}, focus {f} { }
 
 	bool handleInput(const SDL_Event & e, const Position &) override;
 	void render(const UIShader &, const Position & parentPos) const override;
@@ -20,7 +20,7 @@ public:
 
 private:
 	bool ctrl {false}, mrb {false};
-	glm::vec2 focus;
+	Position2D focus;
 	float direction {quarter_pi};
 	float dist {40}, pitch {quarter_pi};
 };
diff --git a/ui/window.h b/ui/window.h
index 183a65a..8f2b70b 100644
--- a/ui/window.h
+++ b/ui/window.h
@@ -36,7 +36,7 @@ protected:
 		GLInitHelper();
 	};
 
-	const glm::ivec2 size;
+	const ScreenAbsCoord size;
 	SDL_WindowPtr m_window;
 	SDL_GLContextPtr glContext;
 	GLInitHelper glInithelper;
-- 
cgit v1.2.3


From 9c2c3f71065c94a18c02440111b6ff8ca977b90e Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Thu, 9 Nov 2023 00:40:40 +0000
Subject: WIP typedefing all the things - sources

---
 assetFactory/cuboid.cpp       |  2 +-
 assetFactory/cylinder.cpp     |  6 +++---
 assetFactory/plane.cpp        |  2 +-
 assetFactory/shape.cpp        |  4 +---
 game/network/link.cpp         | 14 +++++++-------
 game/network/network.cpp      | 18 +++++++++---------
 game/network/rail.cpp         | 30 +++++++++++++++---------------
 game/vehicles/railVehicle.cpp | 12 ++++++------
 game/vehicles/train.cpp       |  2 +-
 gfx/gl/bufferedLocation.cpp   | 12 ++++++------
 gfx/gl/camera.cpp             | 11 ++++++-----
 gfx/gl/sceneRenderer.cpp      |  7 +++----
 gfx/gl/sceneShader.cpp        | 14 +++++++-------
 gfx/gl/shadowMapper.cpp       | 10 +++++-----
 gfx/gl/uiShader.cpp           |  2 +-
 gfx/models/texture.cpp        |  6 +++---
 lib/geometricPlane.cpp        |  4 ++--
 lib/maths.cpp                 | 40 ++++++++++++++++++++--------------------
 lib/ray.cpp                   |  8 ++++----
 test/test-assetFactory.cpp    |  2 +-
 test/testRenderOutput.cpp     |  2 +-
 ui/builders/straight.cpp      |  2 +-
 ui/gameMainSelector.cpp       |  9 +++++----
 ui/gameMainWindow.cpp         |  4 ++--
 ui/manualCameraController.cpp |  2 +-
 25 files changed, 112 insertions(+), 113 deletions(-)

(limited to 'game')

diff --git a/assetFactory/cuboid.cpp b/assetFactory/cuboid.cpp
index a8ddcd9..cfb6cfb 100644
--- a/assetFactory/cuboid.cpp
+++ b/assetFactory/cuboid.cpp
@@ -4,7 +4,7 @@
 Cuboid::CreatedFaces
 Cuboid::createMesh(ModelFactoryMesh & mesh, float) const
 {
-	static constexpr std::array<glm::vec3, 8> VERTICES {{
+	static constexpr std::array<Position3D, 8> VERTICES {{
 			// bottom
 			{n, n, z},
 			{n, y, z},
diff --git a/assetFactory/cylinder.cpp b/assetFactory/cylinder.cpp
index 7d22e36..ed034fd 100644
--- a/assetFactory/cylinder.cpp
+++ b/assetFactory/cylinder.cpp
@@ -9,8 +9,8 @@ Cylinder::createMesh(ModelFactoryMesh & mesh, float lodf) const
 	const auto step = two_pi / static_cast<float>(P);
 
 	// Generate 2D circumference points
-	std::vector<glm::vec2> circumference(P);
-	std::generate(circumference.begin(), circumference.end(), [a = 0.f, step]() mutable {
+	std::vector<Position2D> circumference(P);
+	std::generate(circumference.begin(), circumference.end(), [a = 0.F, step]() mutable {
 		return sincosf(a += step) * .5F;
 	});
 
@@ -19,7 +19,7 @@ Cylinder::createMesh(ModelFactoryMesh & mesh, float lodf) const
 		// Generate bottom face vertices
 		std::vector<OpenMesh::VertexHandle> bottom(P);
 		std::transform(circumference.begin(), circumference.end(), bottom.begin(), [&mesh](const auto & xy) {
-			return mesh.add_vertex(xy ^ 0.f);
+			return mesh.add_vertex(xy ^ 0.F);
 		});
 		surface.insert(mesh.add_namedFace("bottom", bottom));
 	}
diff --git a/assetFactory/plane.cpp b/assetFactory/plane.cpp
index c6e1b5a..28fb690 100644
--- a/assetFactory/plane.cpp
+++ b/assetFactory/plane.cpp
@@ -4,7 +4,7 @@
 Plane::CreatedFaces
 Plane::createMesh(ModelFactoryMesh & mesh, float) const
 {
-	static constexpr std::array<glm::vec3, 4> VERTICES {{
+	static constexpr std::array<Position3D, 4> VERTICES {{
 			{n, n, z},
 			{y, n, z},
 			{y, y, z},
diff --git a/assetFactory/shape.cpp b/assetFactory/shape.cpp
index 1bfbdbb..0f83ee5 100644
--- a/assetFactory/shape.cpp
+++ b/assetFactory/shape.cpp
@@ -1,11 +1,9 @@
 #include "shape.h"
-#include "gfx/models/vertex.h"
-#include "maths.h"
 #include "modelFactoryMesh.h"
 #include "shape.h"
 
 std::vector<OpenMesh::VertexHandle>
-Shape::addToMesh(ModelFactoryMesh & mesh, const std::span<const glm::vec3> vertices)
+Shape::addToMesh(ModelFactoryMesh & mesh, const std::span<const Position3D> vertices)
 {
 	std::vector<OpenMesh::VertexHandle> vhs;
 	std::transform(vertices.begin(), vertices.end(), std::back_inserter(vhs), [&mesh](const auto & p) {
diff --git a/game/network/link.cpp b/game/network/link.cpp
index bb27a52..498afe4 100644
--- a/game/network/link.cpp
+++ b/game/network/link.cpp
@@ -8,10 +8,10 @@
 
 Link::Link(End a, End b, float l) : ends {{std::move(a), std::move(b)}}, length {l} { }
 
-LinkCurve::LinkCurve(glm::vec3 c, float r, Arc a) : centreBase {c}, radius {r}, arc {std::move(a)} { }
+LinkCurve::LinkCurve(Position3D c, float r, Arc a) : centreBase {c}, radius {r}, arc {std::move(a)} { }
 
 bool
-operator<(const glm::vec3 & a, const glm::vec3 & b)
+operator<(const Position3D & a, const Position3D & b)
 {
 	// NOLINTNEXTLINE(hicpp-use-nullptr,modernize-use-nullptr)
 	return std::tie(a.x, a.y, a.z) < std::tie(b.x, b.y, b.z);
@@ -48,7 +48,7 @@ LinkCurve::positionAt(float dist, unsigned char start) const
 	const auto ang {as.first + ((as.second - as.first) * frac)};
 	const auto relPos {!sincosf(ang) * radius};
 	const auto relClimb {vehiclePositionOffset()
-			+ glm::vec3 {0, 0, es.first->pos.z - centreBase.z + ((es.second->pos.z - es.first->pos.z) * frac)}};
+			+ Position3D {0, 0, es.first->pos.z - centreBase.z + ((es.second->pos.z - es.first->pos.z) * frac)}};
 	const auto pitch {vector_pitch({0, 0, (es.second->pos.z - es.first->pos.z) / length})};
 	return Location {relPos + relClimb + centreBase, {pitch, normalize(ang + dirOffset[start]), 0}};
 }
@@ -60,14 +60,14 @@ LinkCurve::intersectRay(const Ray & ray) const
 	const auto & e1p {ends[1].node->pos};
 	const auto slength = round_frac(length / 2.F, 5.F);
 	const auto segs = std::round(15.F * slength / std::pow(radius, 0.7F));
-	const auto step {glm::vec3 {arc_length(arc), e1p.z - e0p.z, slength} / segs};
+	const auto step {Position3D {arc_length(arc), e1p.z - e0p.z, slength} / segs};
 	const auto trans {glm::translate(centreBase)};
 
 	auto segCount = static_cast<std::size_t>(std::lround(segs)) + 1;
-	std::vector<glm::vec3> points;
+	std::vector<Position3D> points;
 	points.reserve(segCount);
-	for (glm::vec3 swing = {arc.first, centreBase.z - e0p.z, 0.F}; segCount; swing += step, --segCount) {
-		const auto t {trans * glm::rotate(half_pi - swing.x, up) * glm::translate(glm::vec3 {radius, 0.F, swing.y})};
+	for (Position3D swing = {arc.first, centreBase.z - e0p.z, 0.F}; segCount; swing += step, --segCount) {
+		const auto t {trans * glm::rotate(half_pi - swing.x, up) * glm::translate(Position3D {radius, 0.F, swing.y})};
 		points.emplace_back(t * glm::vec4 {0, 0, 0, 1});
 	}
 	return ray.passesCloseToEdges(points, 1.F);
diff --git a/game/network/network.cpp b/game/network/network.cpp
index 083b08e..d18345c 100644
--- a/game/network/network.cpp
+++ b/game/network/network.cpp
@@ -14,13 +14,13 @@
 Network::Network(const std::string & tn) : texture {Texture::cachedTexture.get(tn)} { }
 
 Node::Ptr
-Network::nodeAt(glm::vec3 pos)
+Network::nodeAt(Position3D pos)
 {
 	return newNodeAt(pos).first;
 }
 
 Network::NodeInsertion
-Network::newNodeAt(glm::vec3 pos)
+Network::newNodeAt(Position3D pos)
 {
 	if (auto [n, i] = candidateNodeAt(pos); i == NodeIs::NotInNetwork) {
 		return {*nodes.insert(std::move(n)).first, i};
@@ -31,7 +31,7 @@ Network::newNodeAt(glm::vec3 pos)
 }
 
 Node::Ptr
-Network::findNodeAt(glm::vec3 pos) const
+Network::findNodeAt(Position3D pos) const
 {
 	if (const auto n = nodes.find(pos); n != nodes.end()) {
 		return *n;
@@ -40,7 +40,7 @@ Network::findNodeAt(glm::vec3 pos) const
 }
 
 Network::NodeInsertion
-Network::candidateNodeAt(glm::vec3 pos) const
+Network::candidateNodeAt(Position3D pos) const
 {
 	if (const auto n = nodes.find(pos); n != nodes.end()) {
 		return {*n, NodeIs::InNetwork};
@@ -54,7 +54,7 @@ Network::intersectRayNodes(const Ray & ray) const
 	// Click within 2m of a node
 	if (const auto node = std::find_if(nodes.begin(), nodes.end(),
 				[&ray](const Node::Ptr & node) {
-					glm::vec3 ipos, inorm;
+					Position3D ipos, inorm;
 					return glm::intersectRaySphere(ray.start, ray.direction, node->pos, 2.F, ipos, inorm);
 				});
 			node != nodes.end()) {
@@ -79,7 +79,7 @@ Network::joinLinks(const Link::Ptr & l, const Link::Ptr & ol)
 }
 
 Link::Nexts
-Network::routeFromTo(const Link::End & start, glm::vec3 dest) const
+Network::routeFromTo(const Link::End & start, Position3D dest) const
 {
 	auto destNode {findNodeAt(dest)};
 	if (!destNode) {
@@ -95,7 +95,7 @@ Network::routeFromTo(const Link::End & end, const Node::Ptr & dest) const
 }
 
 GenCurveDef
-Network::genCurveDef(const glm::vec3 & start, const glm::vec3 & end, float startDir)
+Network::genCurveDef(const Position3D & start, const Position3D & end, float startDir)
 {
 	const auto diff {end - start};
 	const auto vy {vector_yaw(diff)};
@@ -111,11 +111,11 @@ Network::genCurveDef(const glm::vec3 & start, const glm::vec3 & end, float start
 }
 
 std::pair<GenCurveDef, GenCurveDef>
-Network::genCurveDef(const glm::vec3 & start, const glm::vec3 & end, float startDir, float endDir)
+Network::genCurveDef(const Position3D & start, const Position3D & end, float startDir, float endDir)
 {
 	startDir += pi;
 	endDir += pi;
-	const glm::vec2 flatStart {!start}, flatEnd {!end};
+	const Position2D flatStart {!start}, flatEnd {!end};
 	auto midheight = [&](auto mid) {
 		const auto sm = glm::distance(flatStart, mid), em = glm::distance(flatEnd, mid);
 		return start.z + ((end.z - start.z) * (sm / (sm + em)));
diff --git a/game/network/rail.cpp b/game/network/rail.cpp
index 5a4f1e1..f46504b 100644
--- a/game/network/rail.cpp
+++ b/game/network/rail.cpp
@@ -18,7 +18,7 @@
 template class NetworkOf<RailLink>;
 
 constexpr auto RAIL_CROSSSECTION_VERTICES {5U};
-constexpr glm::vec3 RAIL_HEIGHT {0, 0, .25F};
+constexpr Size3D RAIL_HEIGHT {0, 0, .25F};
 
 RailLinks::RailLinks() : NetworkOf<RailLink> {"rails.jpg"} { }
 
@@ -28,7 +28,7 @@ RailLinks::tick(TickDuration)
 }
 
 std::shared_ptr<RailLink>
-RailLinks::addLinksBetween(glm::vec3 start, glm::vec3 end)
+RailLinks::addLinksBetween(Position3D start, Position3D end)
 {
 	auto node1ins = newNodeAt(start), node2ins = newNodeAt(end);
 	if (node1ins.second == NodeIs::NotInNetwork && node2ins.second == NodeIs::NotInNetwork) {
@@ -45,7 +45,7 @@ RailLinks::addLinksBetween(glm::vec3 start, glm::vec3 end)
 	if (dir == vector_yaw(end - start)) {
 		return addLink<RailLinkStraight>(start, end);
 	}
-	const glm::vec2 flatStart {!start}, flatEnd {!end};
+	const Position2D flatStart {!start}, flatEnd {!end};
 	if (node2ins.second == NodeIs::InNetwork) {
 		auto midheight = [&](auto mid) {
 			const auto sm = glm::distance(flatStart, mid), em = glm::distance(flatEnd, mid);
@@ -100,7 +100,7 @@ RailLink::render(const SceneShader &) const
 	mesh->Draw();
 }
 
-constexpr const std::array<std::pair<glm::vec3, float>, RAIL_CROSSSECTION_VERTICES> railCrossSection {{
+constexpr const std::array<std::pair<Position3D, float>, RAIL_CROSSSECTION_VERTICES> railCrossSection {{
 		//   ___________
 		// _/           \_
 		//  left to right
@@ -122,7 +122,7 @@ RailLinkStraight::RailLinkStraight(const Node::Ptr & a, const Node::Ptr & b) : R
 {
 }
 
-RailLinkStraight::RailLinkStraight(Node::Ptr a, Node::Ptr b, const glm::vec3 & diff) :
+RailLinkStraight::RailLinkStraight(Node::Ptr a, Node::Ptr b, const Position3D & diff) :
 	Link({std::move(a), vector_yaw(diff)}, {std::move(b), vector_yaw(-diff)}, glm::length(diff))
 {
 	if (glGenVertexArrays) {
@@ -133,20 +133,20 @@ RailLinkStraight::RailLinkStraight(Node::Ptr a, Node::Ptr b, const glm::vec3 & d
 		for (auto ei : {1U, 0U}) {
 			const auto trans {glm::translate(ends[ei].node->pos) * e};
 			for (const auto & rcs : railCrossSection) {
-				const glm::vec3 m {(trans * glm::vec4 {rcs.first, 1})};
-				vertices.emplace_back(m, glm::vec2 {rcs.second, len * static_cast<float>(ei)}, up);
+				const Position3D m {(trans * glm::vec4 {rcs.first, 1})};
+				vertices.emplace_back(m, Position2D {rcs.second, len * static_cast<float>(ei)}, up);
 			}
 		}
 		mesh = defaultMesh(vertices);
 	}
 }
 
-RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, glm::vec2 c) :
+RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, Position2D c) :
 	RailLinkCurve(a, b, c ^ a->pos.z, {!c, a->pos, b->pos})
 {
 }
 
-RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, glm::vec3 c, const Arc arc) :
+RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, Position3D c, const Arc arc) :
 	Link({a, normalize(arc.first + half_pi)}, {b, normalize(arc.second - half_pi)},
 			(glm::length(a->pos - c)) * arc_length(arc)),
 	LinkCurve {c, glm::length(ends[0].node->pos - c), arc}
@@ -156,25 +156,25 @@ RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, glm::vec3
 		const auto & e1p {ends[1].node->pos};
 		const auto slength = round_sleepers(length / 2.F);
 		const auto segs = std::round(15.F * slength / std::pow(radius, 0.7F));
-		const auto step {glm::vec3 {arc_length(arc), e1p.z - e0p.z, slength} / segs};
+		const auto step {Position3D {arc_length(arc), e1p.z - e0p.z, slength} / segs};
 		const auto trans {glm::translate(centreBase)};
 
 		auto segCount = static_cast<std::size_t>(std::lround(segs)) + 1;
 		std::vector<Vertex> vertices;
 		vertices.reserve(segCount * railCrossSection.size());
-		for (glm::vec3 swing = {arc.first, centreBase.z - e0p.z, 0.F}; segCount; swing += step, --segCount) {
+		for (Position3D swing = {arc.first, centreBase.z - e0p.z, 0.F}; segCount; swing += step, --segCount) {
 			const auto t {
-					trans * glm::rotate(half_pi - swing.x, up) * glm::translate(glm::vec3 {radius, 0.F, swing.y})};
+					trans * glm::rotate(half_pi - swing.x, up) * glm::translate(Position3D {radius, 0.F, swing.y})};
 			for (const auto & rcs : railCrossSection) {
-				const glm::vec3 m {(t * glm::vec4 {rcs.first, 1})};
-				vertices.emplace_back(m, glm::vec2 {rcs.second, swing.z}, up);
+				const Position3D m {(t * glm::vec4 {rcs.first, 1})};
+				vertices.emplace_back(m, Position2D {rcs.second, swing.z}, up);
 			}
 		}
 		mesh = defaultMesh(vertices);
 	}
 }
 
-glm::vec3
+Position3D
 RailLink::vehiclePositionOffset() const
 {
 	return RAIL_HEIGHT;
diff --git a/game/vehicles/railVehicle.cpp b/game/vehicles/railVehicle.cpp
index 2d820b6..fc43995 100644
--- a/game/vehicles/railVehicle.cpp
+++ b/game/vehicles/railVehicle.cpp
@@ -14,8 +14,8 @@
 RailVehicle::RailVehicle(RailVehicleClassPtr rvc) :
 	RailVehicleClass::Instance {rvc->instances.acquire()}, rvClass {std::move(rvc)}, location {&LV::body, *this},
 	bogies {{
-			{&LV::front, *this, glm::vec3 {0, rvClass->wheelBase / 2.F, 0}},
-			{&LV::back, *this, glm::vec3 {0, -rvClass->wheelBase / 2.F, 0}},
+			{&LV::front, *this, Position3D {0, rvClass->wheelBase / 2.F, 0}},
+			{&LV::back, *this, Position3D {0, -rvClass->wheelBase / 2.F, 0}},
 	}}
 {
 }
@@ -32,13 +32,13 @@ RailVehicle::move(const Train * t, float & trailBy)
 }
 
 bool
-RailVehicle::intersectRay(const Ray & ray, glm::vec2 * baryPos, float * distance) const
+RailVehicle::intersectRay(const Ray & ray, Position2D * baryPos, float * distance) const
 {
 	constexpr const auto X = 1.35F;
 	const auto Y = this->rvClass->length / 2.F;
 	constexpr const auto Z = 3.9F;
 	const auto moveBy = location.getTransform();
-	const std::array<glm::vec3, 8> cornerVertices {{
+	const std::array<Position3D, 8> cornerVertices {{
 			moveBy * glm::vec4 {-X, Y, 0, 1}, //  LFB
 			moveBy * glm::vec4 {X, Y, 0, 1}, //   RFB
 			moveBy * glm::vec4 {-X, Y, Z, 1}, //  LFT
@@ -48,7 +48,7 @@ RailVehicle::intersectRay(const Ray & ray, glm::vec2 * baryPos, float * distance
 			moveBy * glm::vec4 {-X, -Y, Z, 1}, // LBT
 			moveBy * glm::vec4 {X, -Y, Z, 1}, //  RBT
 	}};
-	static constexpr const std::array<glm::uvec3, 10> triangles {{
+	static constexpr const std::array<glm::vec<3, uint8_t>, 10> triangles {{
 			// Front
 			{0, 1, 2},
 			{1, 2, 3},
@@ -66,7 +66,7 @@ RailVehicle::intersectRay(const Ray & ray, glm::vec2 * baryPos, float * distance
 			{3, 6, 7},
 	}};
 	return std::any_of(
-			triangles.begin(), triangles.end(), [&cornerVertices, &ray, &baryPos, &distance](const glm::uvec3 idx) {
+			triangles.begin(), triangles.end(), [&cornerVertices, &ray, &baryPos, &distance](const auto & idx) {
 				return glm::intersectRayTriangle(ray.start, ray.direction, cornerVertices[idx[0]],
 						cornerVertices[idx[1]], cornerVertices[idx[2]], *baryPos, *distance);
 			});
diff --git a/game/vehicles/train.cpp b/game/vehicles/train.cpp
index 6f3b036..4aa24dc 100644
--- a/game/vehicles/train.cpp
+++ b/game/vehicles/train.cpp
@@ -20,7 +20,7 @@ Train::getBogiePosition(float linkDist, float dist) const
 }
 
 bool
-Train::intersectRay(const Ray & ray, glm::vec2 * baryPos, float * distance) const
+Train::intersectRay(const Ray & ray, Position2D * baryPos, float * distance) const
 {
 	return applyOne(&RailVehicle::intersectRay, ray, baryPos, distance) != end();
 }
diff --git a/gfx/gl/bufferedLocation.cpp b/gfx/gl/bufferedLocation.cpp
index eb3dac3..62cadef 100644
--- a/gfx/gl/bufferedLocation.cpp
+++ b/gfx/gl/bufferedLocation.cpp
@@ -3,7 +3,7 @@
 #include "maths.h"
 #include <glm/gtx/transform.hpp>
 
-BufferedLocation::BufferedLocation(glm::vec3 p, glm::vec3 r) : BufferedLocation {Location {p, r}} { }
+BufferedLocation::BufferedLocation(Position3D p, Rotation3D r) : BufferedLocation {Location {p, r}} { }
 
 BufferedLocation::BufferedLocation(const Location & l) : loc {l} { }
 
@@ -20,20 +20,20 @@ BufferedLocation::operator=(const Location & l)
 	return *this;
 }
 
-glm::vec3
+Position3D
 BufferedLocation::position() const
 {
 	return loc.pos;
 }
 
-glm::vec3
+Position3D
 BufferedLocation::rotation() const
 {
 	return loc.rot;
 }
 
 void
-BufferedLocation::setPosition(glm::vec3 p, bool update)
+BufferedLocation::setPosition(Position3D p, bool update)
 {
 	loc.pos = p;
 	if (update) {
@@ -42,7 +42,7 @@ BufferedLocation::setPosition(glm::vec3 p, bool update)
 }
 
 void
-BufferedLocation::setRotation(glm::vec3 r, bool update)
+BufferedLocation::setRotation(Position3D r, bool update)
 {
 	loc.rot = r;
 	if (update) {
@@ -51,7 +51,7 @@ BufferedLocation::setRotation(glm::vec3 r, bool update)
 }
 
 void
-BufferedLocation::setLocation(glm::vec3 p, glm::vec3 r)
+BufferedLocation::setLocation(Position3D p, Rotation3D r)
 {
 	loc.pos = p;
 	loc.rot = r;
diff --git a/gfx/gl/camera.cpp b/gfx/gl/camera.cpp
index 80feab4..6a0359c 100644
--- a/gfx/gl/camera.cpp
+++ b/gfx/gl/camera.cpp
@@ -2,6 +2,7 @@
 #include <collections.h>
 #include <glm/gtx/intersect.hpp> // IWYU pragma: keep
 #include <glm/gtx/transform.hpp> // IWYU pragma: keep
+#include <math.h>
 #include <maths.h>
 #include <ray.h>
 
@@ -28,8 +29,8 @@ Camera::updateView()
 	inverseViewProjection = glm::inverse(viewProjection);
 }
 
-glm::vec3
-Camera::upFromForward(const glm::vec3 & forward)
+Direction3D
+Camera::upFromForward(const Direction3D & forward)
 {
 	const auto right = glm::cross(forward, ::down);
 	return glm::cross(forward, right);
@@ -38,11 +39,11 @@ Camera::upFromForward(const glm::vec3 & forward)
 std::array<glm::vec4, 4>
 Camera::extentsAtDist(const float dist) const
 {
-	const auto clampToSeaFloor = [this, dist](const glm::vec3 & target) {
+	const auto clampToSeaFloor = [this, dist](const Position3D & target) {
 		if (target.z < -1.5F) {
 			const auto vec = glm::normalize(target - position);
-			constexpr glm::vec3 seafloor {0, 0, -1.5F};
-			float outdist;
+			constexpr Position3D seafloor {0, 0, -1.5F};
+			float outdist {};
 			if (glm::intersectRayPlane(position, vec, seafloor, ::up, outdist)) {
 				return (vec * outdist + position) ^ outdist;
 			}
diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index 218cf6d..6965175 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -97,7 +97,7 @@ SceneRenderer::render(const SceneProvider & scene) const
 }
 
 void
-SceneRenderer::setAmbientLight(const glm::vec3 & colour) const
+SceneRenderer::setAmbientLight(const RGB & colour) const
 {
 	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
 	glClearColor(colour.r, colour.g, colour.b, 1.0F);
@@ -105,8 +105,7 @@ SceneRenderer::setAmbientLight(const glm::vec3 & colour) const
 }
 
 void
-SceneRenderer::setDirectionalLight(
-		const glm::vec3 & colour, const glm::vec3 & direction, const SceneProvider & scene) const
+SceneRenderer::setDirectionalLight(const RGB & colour, const Direction3D & direction, const SceneProvider & scene) const
 {
 	if (colour.r > 0 || colour.g > 0 || colour.b > 0) {
 		const auto lvp = shadowMapper.update(scene, direction, camera);
@@ -135,7 +134,7 @@ SceneRenderer::DirectionalLightProgram::DirectionalLightProgram() :
 }
 
 void
-SceneRenderer::DirectionalLightProgram::setDirectionalLight(const glm::vec3 & c, const glm::vec3 & d,
+SceneRenderer::DirectionalLightProgram::setDirectionalLight(const RGB & c, const Direction3D & d,
 		const std::span<const glm::mat4x4> lvp, const std::span<const glm::vec4> shadowMapRegions,
 		std::size_t maps) const
 {
diff --git a/gfx/gl/sceneShader.cpp b/gfx/gl/sceneShader.cpp
index 1354611..04b6d9e 100644
--- a/gfx/gl/sceneShader.cpp
+++ b/gfx/gl/sceneShader.cpp
@@ -81,25 +81,25 @@ void
 SceneShader::WaterProgram::use(float waveCycle) const
 {
 	Program::use();
-	glm::vec3 waves {waveCycle, 0.F, 0.F};
+	Position3D waves {waveCycle, 0.F, 0.F};
 	glUniform3fv(waveLoc, 1, glm::value_ptr(waves));
 }
 
 SceneShader::PointLightShader::PointLightShader() :
 	SceneProgram {pointLight_vs, pointLight_gs, pointLight_fs}, colourLoc {*this, "colour"}, kqLoc {*this, "kq"}
 {
-	VertexArrayObject {va}.addAttribs<glm::vec3>(b);
+	VertexArrayObject {va}.addAttribs<Position3D>(b);
 }
 
 void
-SceneShader::PointLightShader::add(const glm::vec3 & position, const glm::vec3 & colour, const float kq) const
+SceneShader::PointLightShader::add(const Position3D & position, const RGB & colour, const float kq) const
 {
 	Program::use();
 	glBindVertexArray(va);
 	glBindBuffer(GL_ARRAY_BUFFER, b);
 	glUniform3fv(colourLoc, 1, glm::value_ptr(colour));
 	glUniform1f(kqLoc, kq);
-	glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3), glm::value_ptr(position), GL_DYNAMIC_DRAW);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(Position3D), glm::value_ptr(position), GL_DYNAMIC_DRAW);
 	glDrawArrays(GL_POINTS, 0, 1);
 }
 
@@ -107,12 +107,12 @@ SceneShader::SpotLightShader::SpotLightShader() :
 	SceneProgram {spotLight_vs, spotLight_gs, spotLight_fs}, directionLoc {*this, "v_direction"},
 	colourLoc {*this, "colour"}, kqLoc {*this, "kq"}, arcLoc {*this, "arc"}
 {
-	using v3pair = std::pair<glm::vec3, glm::vec3>;
+	using v3pair = std::pair<Position3D, Direction3D>;
 	VertexArrayObject {va}.addAttribs<v3pair, &v3pair::first, &v3pair::second>(b);
 }
 
 void
-SceneShader::SpotLightShader::add(const glm::vec3 & position, const glm::vec3 & direction, const glm::vec3 & colour,
+SceneShader::SpotLightShader::add(const Position3D & position, const Direction3D & direction, const RGB & colour,
 		const float kq, const float arc) const
 {
 	Program::use();
@@ -122,6 +122,6 @@ SceneShader::SpotLightShader::add(const glm::vec3 & position, const glm::vec3 &
 	glUniform3fv(directionLoc, 1, glm::value_ptr(direction));
 	glUniform1f(kqLoc, kq);
 	glUniform1f(arcLoc, arc);
-	glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3), glm::value_ptr(position), GL_DYNAMIC_DRAW);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(Position3D), glm::value_ptr(position), GL_DYNAMIC_DRAW);
 	glDrawArrays(GL_POINTS, 0, 1);
 }
diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 58f65c4..aea5af3 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -104,14 +104,14 @@ struct DefinitionsInserter {
 	ShadowMapper::Definitions & out;
 };
 
-std::vector<std::array<glm::vec3, 4>>
+std::vector<std::array<Position3D, 4>>
 ShadowMapper::getBandViewExtents(const Camera & camera, const glm::mat4 & lightView)
 {
-	std::vector<std::array<glm::vec3, 4>> bandViewExtents;
+	std::vector<std::array<Position3D, 4>> bandViewExtents;
 	for (const auto dist : shadowBands) {
 		const auto extents = camera.extentsAtDist(dist);
-		bandViewExtents.emplace_back(extents * [&lightView](const auto & e) -> glm::vec3 {
-			return lightView * glm::vec4(glm::vec3 {e}, 1);
+		bandViewExtents.emplace_back(extents * [&lightView](const auto & e) -> Position3D {
+			return lightView * glm::vec4(Position3D {e}, 1);
 		});
 		if (std::none_of(extents.begin(), extents.end(), [targetDist = dist * 0.99F](const glm::vec4 & e) {
 				return e.w > targetDist;
@@ -123,7 +123,7 @@ ShadowMapper::getBandViewExtents(const Camera & camera, const glm::mat4 & lightV
 }
 
 ShadowMapper::Definitions
-ShadowMapper::update(const SceneProvider & scene, const glm::vec3 & dir, const Camera & camera) const
+ShadowMapper::update(const SceneProvider & scene, const Direction3D & dir, const Camera & camera) const
 {
 	glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
 	glClear(GL_DEPTH_BUFFER_BIT);
diff --git a/gfx/gl/uiShader.cpp b/gfx/gl/uiShader.cpp
index 0b47211..dc4f4dc 100644
--- a/gfx/gl/uiShader.cpp
+++ b/gfx/gl/uiShader.cpp
@@ -23,7 +23,7 @@ UIShader::UIShader(size_t width, size_t height) :
 UIShader::UIShader(const glm::mat4 & viewProjection) : icon {viewProjection}, text {viewProjection} { }
 
 void
-UIShader::TextProgram::use(const glm::vec3 & colour) const
+UIShader::TextProgram::use(const RGB & colour) const
 {
 	Program::use();
 	glUniform3fv(colorLoc, 1, glm::value_ptr(colour));
diff --git a/gfx/models/texture.cpp b/gfx/models/texture.cpp
index f60d158..1685d34 100644
--- a/gfx/models/texture.cpp
+++ b/gfx/models/texture.cpp
@@ -61,10 +61,10 @@ Texture::bind(GLenum unit) const
 	glBindTexture(type, m_texture);
 }
 
-glm::ivec2
+TextureAbsCoord
 Texture::getSize(const glTexture & texture)
 {
-	glm::ivec2 size;
+	TextureAbsCoord size;
 	glGetTextureLevelParameteriv(texture, 0, GL_TEXTURE_WIDTH, &size.x);
 	glGetTextureLevelParameteriv(texture, 0, GL_TEXTURE_HEIGHT, &size.y);
 	return size;
@@ -137,7 +137,7 @@ TextureAtlas::bind(GLenum unit) const
 }
 
 GLuint
-TextureAtlas::add(glm::ivec2 position, glm::ivec2 size, void * data, TextureOptions to)
+TextureAtlas::add(TextureAbsCoord position, TextureAbsCoord size, void * data, TextureOptions to)
 {
 	glTextureSubImage2D(m_texture, 0, position.x, position.y, size.x, size.y, GL_RGBA, GL_UNSIGNED_BYTE, data);
 
diff --git a/lib/geometricPlane.cpp b/lib/geometricPlane.cpp
index ea4f02d..567f98a 100644
--- a/lib/geometricPlane.cpp
+++ b/lib/geometricPlane.cpp
@@ -4,10 +4,10 @@
 #include <glm/gtx/intersect.hpp>
 
 GeometricPlane::PlaneRelation
-GeometricPlane::getRelation(glm::vec3 p) const
+GeometricPlane::getRelation(Position3D p) const
 {
 	const auto d = glm::dot(normal, p - origin);
-	return d < 0.f ? PlaneRelation::Below : d > 0.f ? PlaneRelation::Above : PlaneRelation::On;
+	return d < 0.F ? PlaneRelation::Below : d > 0.F ? PlaneRelation::Above : PlaneRelation::On;
 }
 
 bool
diff --git a/lib/maths.cpp b/lib/maths.cpp
index 7594b59..5430ef6 100644
--- a/lib/maths.cpp
+++ b/lib/maths.cpp
@@ -6,7 +6,7 @@
 #include <stdexcept>
 
 glm::mat4
-flat_orientation(const glm::vec3 & diff)
+flat_orientation(const Direction3D & diff)
 {
 	static const auto oneeighty {glm::rotate(pi, up)};
 	const auto flatdiff {glm::normalize(!!diff)};
@@ -16,17 +16,17 @@ flat_orientation(const glm::vec3 & diff)
 }
 
 // Helper to lookup into a matrix given an xy vector coordinate
-template<typename M>
+template<typename M, typename I>
 inline auto &
-operator^(M & m, glm::ivec2 xy)
+operator^(M & m, glm::vec<2, I> xy)
 {
 	return m[xy.x][xy.y];
 }
 
 // Create a matrix for the angle, given the targets into the matrix
-template<typename M>
+template<typename M, typename I>
 inline auto
-rotation(typename M::value_type a, glm::ivec2 c1, glm::ivec2 s1, glm::ivec2 c2, glm::ivec2 ms2)
+rotation(typename M::value_type a, glm::vec<2, I> c1, glm::vec<2, I> s1, glm::vec<2, I> c2, glm::vec<2, I> ms2)
 {
 	M m(1);
 	sincosf(a, m ^ s1, m ^ c1);
@@ -39,51 +39,51 @@ rotation(typename M::value_type a, glm::ivec2 c1, glm::ivec2 s1, glm::ivec2 c2,
 glm::mat2
 rotate_flat(float a)
 {
-	return rotation<glm::mat2>(a, {0, 0}, {0, 1}, {1, 1}, {1, 0});
+	return rotation<glm::mat2, glm::length_t>(a, {0, 0}, {0, 1}, {1, 1}, {1, 0});
 }
 
 // Create a yaw transformation matrix
 glm::mat4
 rotate_yaw(float a)
 {
-	return rotation<glm::mat4>(a, {0, 0}, {1, 0}, {1, 1}, {0, 1});
+	return rotation<glm::mat4, glm::length_t>(a, {0, 0}, {1, 0}, {1, 1}, {0, 1});
 }
 
 // Create a roll transformation matrix
 glm::mat4
 rotate_roll(float a)
 {
-	return rotation<glm::mat4>(a, {0, 0}, {2, 0}, {2, 2}, {0, 2});
+	return rotation<glm::mat4, glm::length_t>(a, {0, 0}, {2, 0}, {2, 2}, {0, 2});
 }
 
 // Create a pitch transformation matrix
 glm::mat4
 rotate_pitch(float a)
 {
-	return rotation<glm::mat4>(a, {1, 1}, {1, 2}, {2, 2}, {2, 1});
+	return rotation<glm::mat4, glm::length_t>(a, {1, 1}, {1, 2}, {2, 2}, {2, 1});
 }
 
 // Create a combined yaw, pitch, roll transformation matrix
 glm::mat4
-rotate_ypr(glm::vec3 a)
+rotate_ypr(Rotation3D a)
 {
 	return rotate_yaw(a.y) * rotate_pitch(a.x) * rotate_roll(a.z);
 }
 
 glm::mat4
-rotate_yp(glm::vec2 a)
+rotate_yp(Rotation2D a)
 {
 	return rotate_yaw(a.y) * rotate_pitch(a.x);
 }
 
 float
-vector_yaw(const glm::vec3 & diff)
+vector_yaw(const Direction3D & diff)
 {
 	return std::atan2(diff.x, diff.y);
 }
 
 float
-vector_pitch(const glm::vec3 & diff)
+vector_pitch(const Direction3D & diff)
 {
 	return std::atan(diff.z);
 }
@@ -106,7 +106,7 @@ normalize(float ang)
 	return ang;
 }
 
-Arc::Arc(const glm::vec3 & centre3, const glm::vec3 & e0p, const glm::vec3 & e1p) :
+Arc::Arc(const Position3D & centre3, const Position3D & e0p, const Position3D & e1p) :
 	Arc([&]() -> Arc {
 		const auto diffa = e0p - centre3;
 		const auto diffb = e1p - centre3;
@@ -120,8 +120,8 @@ Arc::Arc(const glm::vec3 & centre3, const glm::vec3 & e0p, const glm::vec3 & e1p
 {
 }
 
-std::pair<glm::vec2, bool>
-find_arc_centre(glm::vec2 as, float entrys, glm::vec2 bs, float entrye)
+std::pair<Position2D, bool>
+find_arc_centre(Position2D as, float entrys, Position2D bs, float entrye)
 {
 	if (as == bs) {
 		return {as, false};
@@ -129,8 +129,8 @@ find_arc_centre(glm::vec2 as, float entrys, glm::vec2 bs, float entrye)
 	return find_arc_centre(as, sincosf(entrys + half_pi), bs, sincosf(entrye - half_pi));
 }
 
-std::pair<glm::vec2, bool>
-find_arc_centre(glm::vec2 as, glm::vec2 ad, glm::vec2 bs, glm::vec2 bd)
+std::pair<Position2D, bool>
+find_arc_centre(Position2D as, Position2D ad, Position2D bs, Position2D bd)
 {
 	const auto det = bd.x * ad.y - bd.y * ad.x;
 	if (det != 0) { // near parallel line will yield noisy results
@@ -142,7 +142,7 @@ find_arc_centre(glm::vec2 as, glm::vec2 ad, glm::vec2 bs, glm::vec2 bd)
 }
 
 std::pair<float, float>
-find_arcs_radius(glm::vec2 start, float entrys, glm::vec2 end, float entrye)
+find_arcs_radius(Position2D start, float entrys, Position2D end, float entrye)
 {
 	const auto getrad = [&](float leftOrRight) {
 		return find_arcs_radius(start, sincosf(entrys + leftOrRight), end, sincosf(entrye + leftOrRight));
@@ -151,7 +151,7 @@ find_arcs_radius(glm::vec2 start, float entrys, glm::vec2 end, float entrye)
 }
 
 float
-find_arcs_radius(glm::vec2 start, glm::vec2 ad, glm::vec2 end, glm::vec2 bd)
+find_arcs_radius(Position2D start, Position2D ad, Position2D end, Position2D bd)
 {
 	// Short name functions for big forula
 	auto sqrt = [](float v) {
diff --git a/lib/ray.cpp b/lib/ray.cpp
index c4e0d8c..9fb3648 100644
--- a/lib/ray.cpp
+++ b/lib/ray.cpp
@@ -2,13 +2,13 @@
 #include <algorithm>
 
 Ray
-Ray::fromPoints(glm::vec3 start, glm::vec3 p)
+Ray::fromPoints(Position3D start, Position3D p)
 {
 	return {start, glm::normalize(p - start)};
 }
 
 float
-Ray::distanceToLine(const glm::vec3 & p1, const glm::vec3 & e1) const
+Ray::distanceToLine(const Position3D & p1, const Position3D & e1) const
 {
 	// https://en.wikipedia.org/wiki/Skew_lines
 	const auto diff = p1 - e1;
@@ -25,10 +25,10 @@ Ray::distanceToLine(const glm::vec3 & p1, const glm::vec3 & e1) const
 }
 
 bool
-Ray::passesCloseToEdges(const std::span<const glm::vec3> positions, float distance) const
+Ray::passesCloseToEdges(const std::span<const Position3D> positions, float distance) const
 {
 	return std::adjacent_find(positions.begin(), positions.end(),
-				   [this, distance](const glm::vec3 & a, const glm::vec3 & b) {
+				   [this, distance](const Position3D & a, const Position3D & b) {
 					   return distanceToLine(a, b) <= distance;
 				   })
 			!= positions.end();
diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 177ab6a..9af08cb 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -25,7 +25,7 @@ BOOST_GLOBAL_FIXTURE(TestMainWindow);
 
 const std::filesystem::path TMP {"/tmp"};
 
-class FactoryFixture : public TestRenderOutputSize<glm::ivec2 {2048, 1024}>, public SceneProvider {
+class FactoryFixture : public TestRenderOutputSize<TextureAbsCoord {2048, 1024}>, public SceneProvider {
 public:
 	FactoryFixture() : sceneRenderer {size, output} { }
 
diff --git a/test/testRenderOutput.cpp b/test/testRenderOutput.cpp
index 464b0b3..9af4451 100644
--- a/test/testRenderOutput.cpp
+++ b/test/testRenderOutput.cpp
@@ -1,7 +1,7 @@
 #include "testRenderOutput.h"
 #include <stdexcept>
 
-TestRenderOutput::TestRenderOutput(glm::ivec2 s) : size {s}
+TestRenderOutput::TestRenderOutput(TextureAbsCoord s) : size {s}
 {
 	glBindFramebuffer(GL_FRAMEBUFFER, output);
 	const auto configuregdata
diff --git a/ui/builders/straight.cpp b/ui/builders/straight.cpp
index 4fa9585..9b262bb 100644
--- a/ui/builders/straight.cpp
+++ b/ui/builders/straight.cpp
@@ -47,7 +47,7 @@ BuilderStraight::click(Network * network, const GeoData * geoData, const SDL_Mou
 }
 
 void
-BuilderStraight::create(Network * network, glm::vec3 p1, glm::vec3 p2) const
+BuilderStraight::create(Network * network, Position3D p1, Position3D p2) const
 {
 	network->addStraight(p1, p2);
 }
diff --git a/ui/gameMainSelector.cpp b/ui/gameMainSelector.cpp
index 808e0e4..a451ee1 100644
--- a/ui/gameMainSelector.cpp
+++ b/ui/gameMainSelector.cpp
@@ -8,6 +8,7 @@
 #include <game/selectable.h>
 #include <game/worldobject.h> // IWYU pragma: keep
 #include <gfx/gl/camera.h>
+#include <math.h>
 #include <optional>
 #include <span>
 #include <stream_support.h>
@@ -16,7 +17,7 @@
 
 GameMainSelector::GameMainSelector(const Camera * c, ScreenAbsCoord size) : UIComponent {{{}, size}}, camera {c} { }
 
-constexpr glm::vec2 TargetPos {5, 45};
+constexpr ScreenAbsCoord TargetPos {5, 45};
 
 void
 GameMainSelector::render(const UIShader & shader, const Position & parentPos) const
@@ -41,7 +42,7 @@ bool
 GameMainSelector::handleInput(const SDL_Event & e, const Position & parentPos)
 {
 	const auto getRay = [this](const auto & e) {
-		const auto mouse = glm::vec2 {e.x, e.y} / position.size;
+		const auto mouse = ScreenRelCoord {e.x, e.y} / position.size;
 		return camera->unProject(mouse);
 	};
 	if (target) {
@@ -72,8 +73,8 @@ GameMainSelector::handleInput(const SDL_Event & e, const Position & parentPos)
 void
 GameMainSelector::defaultClick(const Ray & ray)
 {
-	glm::vec2 baryPos {};
-	float distance;
+	Position2D baryPos {};
+	float distance {};
 
 	if (const auto selected
 			= gameState->world.applyOne<Selectable>(&Selectable::intersectRay, ray, &baryPos, &distance);
diff --git a/ui/gameMainWindow.cpp b/ui/gameMainWindow.cpp
index b94accd..15f1e07 100644
--- a/ui/gameMainWindow.cpp
+++ b/ui/gameMainWindow.cpp
@@ -31,8 +31,8 @@ public:
 GameMainWindow::GameMainWindow(size_t w, size_t h) :
 	Window {w, h, "I Like Trains", SDL_WINDOW_OPENGL}, SceneRenderer {Window::size, 0}
 {
-	uiComponents.create<ManualCameraController>(glm::vec2 {-1150, -1150});
-	auto gms = uiComponents.create<GameMainSelector>(&camera, glm::vec2 {w, h});
+	uiComponents.create<ManualCameraController>(Position2D {-1150, -1150});
+	auto gms = uiComponents.create<GameMainSelector>(&camera, ScreenAbsCoord {w, h});
 	uiComponents.create<GameMainToolbar>(gms.get());
 }
 
diff --git a/ui/manualCameraController.cpp b/ui/manualCameraController.cpp
index 8e52b0e..05c1fc5 100644
--- a/ui/manualCameraController.cpp
+++ b/ui/manualCameraController.cpp
@@ -59,7 +59,7 @@ ManualCameraController::handleInput(const SDL_Event & e, const Position &)
 					pitch = std::clamp(pitch - 0.01F * static_cast<float>(e.motion.yrel), 0.1F, half_pi);
 				}
 				else {
-					focus += rotate_flat(-direction) * glm::vec2 {-e.motion.xrel, e.motion.yrel};
+					focus += rotate_flat(-direction) * Position2D {-e.motion.xrel, e.motion.yrel};
 				}
 			}
 			return true;
-- 
cgit v1.2.3


From d771fbda2c171cfbc36cc0eb3122c1a02ffbb081 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Thu, 9 Nov 2023 01:57:27 +0000
Subject: WIP typedefing just about everything else

---
 assetFactory/assetFactory.h     |  5 ++---
 assetFactory/modelFactoryMesh.h |  9 ++++----
 assetFactory/style.cpp          | 14 ++++++------
 assetFactory/style.h            |  6 ++----
 config/types.h                  |  3 +++
 game/network/network.h          |  2 +-
 game/network/rail.cpp           |  4 ++--
 gfx/gl/sceneRenderer.cpp        |  2 +-
 gfx/gl/sceneRenderer.h          |  2 +-
 gfx/gl/sceneShader.cpp          |  4 ++--
 gfx/gl/sceneShader.h            |  4 ++--
 gfx/gl/shadowMapper.cpp         | 47 +++++++++++++++++++++--------------------
 gfx/gl/shadowMapper.h           |  2 +-
 ui/editNetwork.h                |  2 +-
 14 files changed, 54 insertions(+), 52 deletions(-)

(limited to 'game')

diff --git a/assetFactory/assetFactory.h b/assetFactory/assetFactory.h
index e449ce2..787f0a4 100644
--- a/assetFactory/assetFactory.h
+++ b/assetFactory/assetFactory.h
@@ -15,10 +15,9 @@ public:
 	using Assets = std::map<std::string, Asset::Ptr, std::less<>>;
 	using AssImps = std::map<std::string, AssImp::Ptr, std::less<>>;
 	using TextureFragments = std::map<std::string, TextureFragment::Ptr, std::less<>>;
-	using Colour = glm::vec3;
-	using ColourAlpha = glm::vec4;
+	using Colour = RGB;
+	using ColourAlpha = RGBA;
 	using Colours = std::map<std::string, Colour, std::less<>>;
-	using TextureFragmentCoords = std::array<glm::vec2, 4>;
 
 	AssetFactory();
 	[[nodiscard]] static std::shared_ptr<AssetFactory> loadXML(const std::filesystem::path &);
diff --git a/assetFactory/modelFactoryMesh.h b/assetFactory/modelFactoryMesh.h
index 32e7ab5..480bf7f 100644
--- a/assetFactory/modelFactoryMesh.h
+++ b/assetFactory/modelFactoryMesh.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "config/types.h"
 #include "modelFactoryMesh_fwd.h"
 #include <OpenMesh/Core/Mesh/PolyMesh_ArrayKernelT.hh>
 #include <OpenMesh/Core/Mesh/Traits.hh>
@@ -38,10 +39,10 @@ struct ModelFactoryTraits : public OpenMesh::DefaultTraits {
 	EdgeAttributes(OpenMesh::Attributes::Status);
 	VertexAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
 	HalfedgeAttributes(OpenMesh::Attributes::TexCoord2D);
-	using Point = glm::vec3;
-	using Normal = glm::vec3;
-	using Color = glm::vec4;
-	using TexCoord2D = glm::vec2;
+	using Point = Position3D;
+	using Normal = Normal3D;
+	using Color = RGBA;
+	using TexCoord2D = TextureRelCoord;
 };
 
 struct ModelFactoryMesh : public OpenMesh::PolyMesh_ArrayKernelT<ModelFactoryTraits> {
diff --git a/assetFactory/style.cpp b/assetFactory/style.cpp
index 81a5441..265becb 100644
--- a/assetFactory/style.cpp
+++ b/assetFactory/style.cpp
@@ -33,10 +33,10 @@ Style::applyStyle(
 			const auto material = mf->getMaterialIndex(texture);
 			mesh.property(mesh.materialFaceProperty, face) = material;
 			static constexpr std::array<ModelFactoryTraits::TexCoord2D, 4> coords {{
-					{0.f, 0.f},
-					{1.f, 0.f},
-					{1.f, 1.f},
-					{0.f, 1.f},
+					{0.F, 0.F},
+					{1.F, 0.F},
+					{1.F, 1.F},
+					{0.F, 1.F},
 			}};
 			auto coord = coords.begin();
 			// Wild assumption that face is a quad and the texture should apply linearly
@@ -58,9 +58,9 @@ Style::getColour(const StyleStack & parents)
 bool
 Style::persist(Persistence::PersistenceStore & store)
 {
-	struct ColourParser : public Persistence::SelectionV<ColourAlpha> {
-		using Persistence::SelectionV<ColourAlpha>::SelectionV;
-		using Persistence::SelectionV<ColourAlpha>::setValue;
+	struct ColourParser : public Persistence::SelectionV<RGBA> {
+		using Persistence::SelectionV<RGBA>::SelectionV;
+		using Persistence::SelectionV<RGBA>::setValue;
 
 		void
 		setValue(std::string && str) override
diff --git a/assetFactory/style.h b/assetFactory/style.h
index d931f98..2a437aa 100644
--- a/assetFactory/style.h
+++ b/assetFactory/style.h
@@ -10,9 +10,7 @@
 class Style {
 public:
 	using StyleStack = std::vector<const Style *>;
-	using Colour = glm::vec3;
-	using ColourAlpha = glm::vec4;
-	using EffectiveColour = std::optional<std::reference_wrapper<const ColourAlpha>>;
+	using EffectiveColour = std::optional<std::reference_wrapper<const RGBA>>;
 
 	void applyStyle(ModelFactoryMesh &, const StyleStack & parents, const Shape::CreatedFaces &) const;
 	void applyStyle(ModelFactoryMesh &, const StyleStack & parents, const ModelFactoryMesh::FaceHandle &) const;
@@ -30,7 +28,7 @@ public:
 
 	static EffectiveColour getColour(const StyleStack & parents);
 
-	ColourAlpha colour {};
+	RGBA colour {};
 	std::optional<bool> smooth;
 	std::string texture;
 	std::string textureRotation; // Multiples of 90deg, no int/enum support
diff --git a/config/types.h b/config/types.h
index a84be90..d99735e 100644
--- a/config/types.h
+++ b/config/types.h
@@ -27,8 +27,11 @@ using Normal3D = Normal<3>;
 using Rotation2D = Rotation<2>;
 using Rotation3D = Rotation<3>;
 using TextureRelCoord = glm::vec<2, float>;
+using TextureRelRegion = glm::vec<4, float>;
 using TextureAbsCoord = glm::vec<2, GLsizei>;
+using TextureAbsRegion = glm::vec<4, GLsizei>;
 using RGB = Colour<3>;
 using RGBA = Colour<4>;
 using ScreenRelCoord = glm::vec<2, float>;
 using ScreenAbsCoord = glm::vec<2, uint16_t>;
+using ViewPort = glm::vec<4, GLsizei>;
diff --git a/game/network/network.h b/game/network/network.h
index 02f8c30..8af06a9 100644
--- a/game/network/network.h
+++ b/game/network/network.h
@@ -16,7 +16,7 @@ class Texture;
 class SceneShader;
 class Ray;
 
-template<size_t... n> using GenDef = std::tuple<glm::vec<n, float>...>;
+template<size_t... n> using GenDef = std::tuple<glm::vec<n, Distance>...>;
 using GenCurveDef = GenDef<3, 3, 2>;
 
 class Network {
diff --git a/game/network/rail.cpp b/game/network/rail.cpp
index f46504b..cc61db9 100644
--- a/game/network/rail.cpp
+++ b/game/network/rail.cpp
@@ -133,7 +133,7 @@ RailLinkStraight::RailLinkStraight(Node::Ptr a, Node::Ptr b, const Position3D &
 		for (auto ei : {1U, 0U}) {
 			const auto trans {glm::translate(ends[ei].node->pos) * e};
 			for (const auto & rcs : railCrossSection) {
-				const Position3D m {(trans * glm::vec4 {rcs.first, 1})};
+				const Position3D m {(trans * (rcs.first ^ 1))};
 				vertices.emplace_back(m, Position2D {rcs.second, len * static_cast<float>(ei)}, up);
 			}
 		}
@@ -166,7 +166,7 @@ RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, Position3
 			const auto t {
 					trans * glm::rotate(half_pi - swing.x, up) * glm::translate(Position3D {radius, 0.F, swing.y})};
 			for (const auto & rcs : railCrossSection) {
-				const Position3D m {(t * glm::vec4 {rcs.first, 1})};
+				const Position3D m {(t * (rcs.first ^ 1))};
 				vertices.emplace_back(m, Position2D {rcs.second, swing.z}, up);
 			}
 		}
diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index 6965175..4a3fec9 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -135,7 +135,7 @@ SceneRenderer::DirectionalLightProgram::DirectionalLightProgram() :
 
 void
 SceneRenderer::DirectionalLightProgram::setDirectionalLight(const RGB & c, const Direction3D & d,
-		const std::span<const glm::mat4x4> lvp, const std::span<const glm::vec4> shadowMapRegions,
+		const std::span<const glm::mat4x4> lvp, const std::span<const TextureRelRegion> shadowMapRegions,
 		std::size_t maps) const
 {
 	glUniform3fv(colourLoc, 1, glm::value_ptr(c));
diff --git a/gfx/gl/sceneRenderer.h b/gfx/gl/sceneRenderer.h
index 87f474b..30fd8d3 100644
--- a/gfx/gl/sceneRenderer.h
+++ b/gfx/gl/sceneRenderer.h
@@ -40,7 +40,7 @@ private:
 		using Program::use;
 
 		void setDirectionalLight(const RGB &, const Direction3D &, const std::span<const glm::mat4x4>,
-				const std::span<const glm::vec4>, std::size_t maps) const;
+				const std::span<const TextureRelRegion>, std::size_t maps) const;
 
 	private:
 		RequiredUniformLocation directionLoc, colourLoc, lightViewProjectionLoc, lightViewProjectionCountLoc,
diff --git a/gfx/gl/sceneShader.cpp b/gfx/gl/sceneShader.cpp
index 04b6d9e..2dc2e70 100644
--- a/gfx/gl/sceneShader.cpp
+++ b/gfx/gl/sceneShader.cpp
@@ -35,7 +35,7 @@ SceneShader::setViewProjection(const glm::mat4 & viewProjection) const
 }
 
 void
-SceneShader::setViewPort(const glm::ivec4 & viewPort) const
+SceneShader::setViewPort(const ViewPort & viewPort) const
 {
 	for (const auto & prog : std::array<const SceneProgram *, 7> {
 				 &basic, &basicInst, &water, &landmass, &absolute, &pointLight, &spotLight}) {
@@ -51,7 +51,7 @@ SceneShader::SceneProgram::setViewProjection(const glm::mat4 & viewProjection) c
 }
 
 void
-SceneShader::SceneProgram::setViewPort(const glm::ivec4 & viewPort) const
+SceneShader::SceneProgram::setViewPort(const ViewPort & viewPort) const
 {
 	if (viewPortLoc >= 0) {
 		glUseProgram(*this);
diff --git a/gfx/gl/sceneShader.h b/gfx/gl/sceneShader.h
index d1c6ef2..f46b842 100644
--- a/gfx/gl/sceneShader.h
+++ b/gfx/gl/sceneShader.h
@@ -16,7 +16,7 @@ class SceneShader {
 		}
 
 		void setViewProjection(const glm::mat4 &) const;
-		void setViewPort(const glm::ivec4 &) const;
+		void setViewPort(const ViewPort &) const;
 
 	private:
 		RequiredUniformLocation viewProjectionLoc;
@@ -88,5 +88,5 @@ public:
 	SpotLightShader spotLight;
 
 	void setViewProjection(const glm::mat4 & viewProjection) const;
-	void setViewPort(const glm::ivec4 & viewPort) const;
+	void setViewPort(const ViewPort & viewPort) const;
 };
diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index aea5af3..94a0791 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -24,7 +24,7 @@ ShadowMapper::ShadowMapper(const TextureAbsCoord & s) :
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-	static constexpr glm::vec4 border {std::numeric_limits<float>::infinity()};
+	static constexpr RGBA border {std::numeric_limits<RGBA::value_type>::infinity()};
 	glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, glm::value_ptr(border));
 
 	glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
@@ -37,7 +37,7 @@ ShadowMapper::ShadowMapper(const TextureAbsCoord & s) :
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
-constexpr std::array<std::array<glm::ivec4, ShadowMapper::SHADOW_BANDS>, ShadowMapper::SHADOW_BANDS> viewports {{
+constexpr std::array<std::array<TextureAbsRegion, ShadowMapper::SHADOW_BANDS>, ShadowMapper::SHADOW_BANDS> viewports {{
 		{{
 				{31, 31, 0, 0}, // full
 		}},
@@ -57,27 +57,28 @@ constexpr std::array<std::array<glm::ivec4, ShadowMapper::SHADOW_BANDS>, ShadowM
 				{1, 1, 1, 1}, // upper right
 		}},
 }};
-constexpr std::array<std::array<glm::vec4, ShadowMapper::SHADOW_BANDS>, ShadowMapper::SHADOW_BANDS> shadowMapRegions {{
-		{{
-				{0.5F, 0.5F, 0.5F, 0.5F}, // full
-		}},
-		{{
-				{0.5F, 0.25F, 0.5F, 0.25F}, // lower half
-				{0.5F, 0.25F, 0.5F, 0.75F}, // upper half
-		}},
-		{{
-				{0.5F, 0.25F, 0.5F, 0.25F}, // lower half
-				{0.25F, 0.25F, 0.25F, 0.75F}, // upper left
-				{0.25F, 0.25F, 0.75F, 0.75F}, // upper right
-		}},
-
-		{{
-				{0.25F, 0.25F, 0.25F, 0.25F}, // lower left
-				{0.25F, 0.25F, 0.75F, 0.25F}, // lower right
-				{0.25F, 0.25F, 0.25F, 0.75F}, // upper left
-				{0.25F, 0.25F, 0.75F, 0.75F}, // upper right
-		}},
-}};
+constexpr std::array<std::array<TextureAbsRegion, ShadowMapper::SHADOW_BANDS>, ShadowMapper::SHADOW_BANDS>
+		shadowMapRegions {{
+				{{
+						{0.5F, 0.5F, 0.5F, 0.5F}, // full
+				}},
+				{{
+						{0.5F, 0.25F, 0.5F, 0.25F}, // lower half
+						{0.5F, 0.25F, 0.5F, 0.75F}, // upper half
+				}},
+				{{
+						{0.5F, 0.25F, 0.5F, 0.25F}, // lower half
+						{0.25F, 0.25F, 0.25F, 0.75F}, // upper left
+						{0.25F, 0.25F, 0.75F, 0.75F}, // upper right
+				}},
+
+				{{
+						{0.25F, 0.25F, 0.25F, 0.25F}, // lower left
+						{0.25F, 0.25F, 0.75F, 0.25F}, // lower right
+						{0.25F, 0.25F, 0.25F, 0.75F}, // upper left
+						{0.25F, 0.25F, 0.75F, 0.75F}, // upper right
+				}},
+		}};
 constexpr std::array<float, ShadowMapper::SHADOW_BANDS + 1> shadowBands {
 		1.F,
 		250.F,
diff --git a/gfx/gl/shadowMapper.h b/gfx/gl/shadowMapper.h
index e5272a3..d54734c 100644
--- a/gfx/gl/shadowMapper.h
+++ b/gfx/gl/shadowMapper.h
@@ -18,7 +18,7 @@ public:
 
 	struct Definitions {
 		std::array<glm::mat4x4, SHADOW_BANDS> projections {};
-		std::array<glm::vec4, SHADOW_BANDS> regions {};
+		std::array<TextureRelRegion, SHADOW_BANDS> regions {};
 		size_t maps {};
 	};
 
diff --git a/ui/editNetwork.h b/ui/editNetwork.h
index eb1677e..e1aaa61 100644
--- a/ui/editNetwork.h
+++ b/ui/editNetwork.h
@@ -21,7 +21,7 @@ public:
 	void render(const SceneShader &) const override;
 	void render(const UIShader & shader, const UIComponent::Position & pos) const override;
 
-	using NetworkClickPos = std::variant<glm::vec3, Node::Ptr>;
+	using NetworkClickPos = std::variant<Position3D, Node::Ptr>;
 
 	class Builder {
 	public:
-- 
cgit v1.2.3


From 5e25d79beef19c39537b0f15982a175fec45bb3e Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 11 Nov 2023 17:37:57 +0000
Subject: Refactor BufferedLocationT to use a callback

Simplifies customisation in the face of multiple fields
---
 game/vehicles/railVehicle.cpp | 15 ++++++++++++---
 game/vehicles/railVehicle.h   |  5 ++---
 gfx/gl/bufferedLocation.cpp   |  7 ++++++-
 gfx/gl/bufferedLocation.h     | 18 +++++++-----------
 4 files changed, 27 insertions(+), 18 deletions(-)

(limited to 'game')

diff --git a/game/vehicles/railVehicle.cpp b/game/vehicles/railVehicle.cpp
index fc43995..1ed904d 100644
--- a/game/vehicles/railVehicle.cpp
+++ b/game/vehicles/railVehicle.cpp
@@ -12,10 +12,19 @@
 #include <ray.h>
 
 RailVehicle::RailVehicle(RailVehicleClassPtr rvc) :
-	RailVehicleClass::Instance {rvc->instances.acquire()}, rvClass {std::move(rvc)}, location {&LV::body, *this},
+	RailVehicleClass::Instance {rvc->instances.acquire()}, rvClass {std::move(rvc)},
+	location {[this](const BufferedLocation * l) {
+		this->get()->body = l->getTransform();
+	}},
 	bogies {{
-			{&LV::front, *this, Position3D {0, rvClass->wheelBase / 2.F, 0}},
-			{&LV::back, *this, Position3D {0, -rvClass->wheelBase / 2.F, 0}},
+			{[this](const BufferedLocation * l) {
+				 this->get()->front = l->getTransform();
+			 },
+					Position3D {0, rvClass->wheelBase / 2.F, 0}},
+			{[this](const BufferedLocation * l) {
+				 this->get()->back = l->getTransform();
+			 },
+					Position3D {0, -rvClass->wheelBase / 2.F, 0}},
 	}}
 {
 }
diff --git a/game/vehicles/railVehicle.h b/game/vehicles/railVehicle.h
index e034852..20d1ea1 100644
--- a/game/vehicles/railVehicle.h
+++ b/game/vehicles/railVehicle.h
@@ -21,9 +21,8 @@ public:
 
 	RailVehicleClassPtr rvClass;
 	using LV = RailVehicleClass::LocationVertex;
-	using BLocation = BufferedLocationT<glm::mat4 LV::*, RailVehicleClass::Instance &>;
-	BLocation location;
-	std::array<BLocation, 2> bogies;
+	BufferedLocationUpdater location;
+	std::array<BufferedLocationUpdater, 2> bogies;
 };
 
 using RailVehiclePtr = std::unique_ptr<RailVehicle>;
diff --git a/gfx/gl/bufferedLocation.cpp b/gfx/gl/bufferedLocation.cpp
index 6ba8812..412e3ab 100644
--- a/gfx/gl/bufferedLocation.cpp
+++ b/gfx/gl/bufferedLocation.cpp
@@ -1,6 +1,5 @@
 #include "bufferedLocation.h"
 #include "location.h"
-#include "maths.h"
 #include <glm/gtx/transform.hpp>
 
 BufferedLocation::BufferedLocation(Position3D p, Rotation3D r) : BufferedLocation {Location {p, r}} { }
@@ -69,3 +68,9 @@ BufferedLocation::getRotationTransform() const
 {
 	return loc.getRotationTransform();
 }
+
+void
+BufferedLocationUpdater::updateBuffer() const
+{
+	onUpdate(this);
+}
diff --git a/gfx/gl/bufferedLocation.h b/gfx/gl/bufferedLocation.h
index 8302b3c..a5cd23e 100644
--- a/gfx/gl/bufferedLocation.h
+++ b/gfx/gl/bufferedLocation.h
@@ -4,7 +4,7 @@
 #include <functional>
 #include <glm/mat4x4.hpp>
 #include <glm/vec3.hpp>
-#include <tuple>
+#include <utility>
 
 class BufferedLocation {
 public:
@@ -26,16 +26,16 @@ public:
 	[[nodiscard]] glm::mat4 getRotationTransform() const;
 
 private:
-	virtual void updateBuffer() = 0;
+	virtual void updateBuffer() const = 0;
 
 	Location loc;
 };
 
-template<typename... Target> class BufferedLocationT : public BufferedLocation {
+class BufferedLocationUpdater : public BufferedLocation {
 public:
 	template<typename... LocationArgs>
-	BufferedLocationT(Target &&... target, LocationArgs &&... t) :
-		BufferedLocation {std::forward<LocationArgs>(t)...}, target {std::forward<Target>(target)...}
+	BufferedLocationUpdater(std::function<void(const BufferedLocation *)> onUpdate, LocationArgs &&... t) :
+		BufferedLocation {std::forward<LocationArgs>(t)...}, onUpdate {std::move(onUpdate)}
 	{
 		updateBuffer();
 	}
@@ -43,11 +43,7 @@ public:
 	using BufferedLocation::operator=;
 
 private:
-	void
-	updateBuffer() override
-	{
-		std::apply(std::invoke<const Target &...>, target) = getTransform();
-	}
+	void updateBuffer() const override;
 
-	std::tuple<Target...> target;
+	std::function<void(const BufferedLocation *)> onUpdate;
 };
-- 
cgit v1.2.3


From 356e874050e5ad5af87b04a2bb01ce34a86640bb Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Mon, 13 Nov 2023 00:17:11 +0000
Subject: Send position and rotation matrix to GPU separately

---
 game/scenary/foliage.cpp                 |  3 ++-
 game/scenary/foliage.h                   |  3 ++-
 game/scenary/plant.cpp                   |  2 +-
 game/scenary/plant.h                     |  2 +-
 game/vehicles/railVehicle.cpp            |  9 ++++++---
 game/vehicles/railVehicleClass.cpp       |  8 +++++---
 game/vehicles/railVehicleClass.h         |  1 +
 gfx/gl/camera.cpp                        |  9 ++++-----
 gfx/gl/sceneRenderer.cpp                 |  2 +-
 gfx/gl/sceneShader.cpp                   | 13 ++++++++-----
 gfx/gl/sceneShader.h                     | 11 +++++++----
 gfx/gl/shaders/commonPoint.glsl          |  2 +-
 gfx/gl/shaders/commonShadowPoint.glsl    |  3 ++-
 gfx/gl/shaders/dynamicPoint.vs           |  2 ++
 gfx/gl/shaders/dynamicPointInst.vs       |  2 ++
 gfx/gl/shaders/fixedPoint.vs             |  2 ++
 gfx/gl/shaders/pointLight.gs             |  1 +
 gfx/gl/shaders/pointLight.vs             |  3 ++-
 gfx/gl/shaders/shadowDynamicPoint.vs     |  2 ++
 gfx/gl/shaders/shadowDynamicPointInst.vs |  2 ++
 gfx/gl/shaders/shadowFixedPoint.vs       |  2 ++
 gfx/gl/shaders/spotLight.gs              |  1 +
 gfx/gl/shaders/spotLight.vs              |  3 ++-
 gfx/gl/shaders/water.vs                  |  7 ++++---
 24 files changed, 63 insertions(+), 32 deletions(-)

(limited to 'game')

diff --git a/game/scenary/foliage.cpp b/game/scenary/foliage.cpp
index 702a52c..c258b77 100644
--- a/game/scenary/foliage.cpp
+++ b/game/scenary/foliage.cpp
@@ -15,7 +15,8 @@ void
 Foliage::postLoad()
 {
 	texture = getTexture();
-	bodyMesh->configureVAO(instanceVAO).addAttribs<glm::mat4>(instances.bufferName(), 1);
+	bodyMesh->configureVAO(instanceVAO)
+			.addAttribs<LocationVertex, &LocationVertex::first, &LocationVertex::second>(instances.bufferName(), 1);
 }
 
 void
diff --git a/game/scenary/foliage.h b/game/scenary/foliage.h
index b72a9c2..5a9d2de 100644
--- a/game/scenary/foliage.h
+++ b/game/scenary/foliage.h
@@ -15,7 +15,8 @@ class Foliage : public Asset, public Renderable, public StdTypeDefs<Foliage> {
 	glVertexArray instanceVAO;
 
 public:
-	mutable InstanceVertices<glm::mat4> instances;
+	using LocationVertex = std::pair<glm::mat4, Position3D>;
+	mutable InstanceVertices<LocationVertex> instances;
 	void render(const SceneShader &) const override;
 	void shadows(const ShadowMapper &) const override;
 
diff --git a/game/scenary/plant.cpp b/game/scenary/plant.cpp
index 4fb3cb5..b39c28b 100644
--- a/game/scenary/plant.cpp
+++ b/game/scenary/plant.cpp
@@ -2,6 +2,6 @@
 #include "location.h"
 
 Plant::Plant(std::shared_ptr<const Foliage> type, const Location & position) :
-	type {std::move(type)}, location {this->type->instances.acquire(position.getTransform())}
+	type {std::move(type)}, location {this->type->instances.acquire(position.getRotationTransform(), position.pos)}
 {
 }
diff --git a/game/scenary/plant.h b/game/scenary/plant.h
index 82ab0e5..77c9ff7 100644
--- a/game/scenary/plant.h
+++ b/game/scenary/plant.h
@@ -7,7 +7,7 @@ class Location;
 
 class Plant : public WorldObject {
 	std::shared_ptr<const Foliage> type;
-	InstanceVertices<glm::mat4>::InstanceProxy location;
+	InstanceVertices<Foliage::LocationVertex>::InstanceProxy location;
 
 	void
 	tick(TickDuration) override
diff --git a/game/vehicles/railVehicle.cpp b/game/vehicles/railVehicle.cpp
index 1ed904d..6e6e18f 100644
--- a/game/vehicles/railVehicle.cpp
+++ b/game/vehicles/railVehicle.cpp
@@ -14,15 +14,18 @@
 RailVehicle::RailVehicle(RailVehicleClassPtr rvc) :
 	RailVehicleClass::Instance {rvc->instances.acquire()}, rvClass {std::move(rvc)},
 	location {[this](const BufferedLocation * l) {
-		this->get()->body = l->getTransform();
+		this->get()->body = l->getRotationTransform();
+		this->get()->bodyPos = l->position();
 	}},
 	bogies {{
 			{[this](const BufferedLocation * l) {
-				 this->get()->front = l->getTransform();
+				 this->get()->front = l->getRotationTransform();
+				 this->get()->frontPos = l->position();
 			 },
 					Position3D {0, rvClass->wheelBase / 2.F, 0}},
 			{[this](const BufferedLocation * l) {
-				 this->get()->back = l->getTransform();
+				 this->get()->back = l->getRotationTransform();
+				 this->get()->backPos = l->position();
 			 },
 					Position3D {0, -rvClass->wheelBase / 2.F, 0}},
 	}}
diff --git a/game/vehicles/railVehicleClass.cpp b/game/vehicles/railVehicleClass.cpp
index 324148c..7a6a9fe 100644
--- a/game/vehicles/railVehicleClass.cpp
+++ b/game/vehicles/railVehicleClass.cpp
@@ -35,13 +35,15 @@ void
 RailVehicleClass::postLoad()
 {
 	texture = getTexture();
-	bodyMesh->configureVAO(instanceVAO).addAttribs<LocationVertex, &LocationVertex::body>(instances.bufferName(), 1);
+	bodyMesh->configureVAO(instanceVAO)
+			.addAttribs<LocationVertex, &LocationVertex::body, &LocationVertex::bodyPos>(instances.bufferName(), 1);
 	bogies.front()
 			->configureVAO(instancesBogiesVAO.front())
-			.addAttribs<LocationVertex, &LocationVertex::front>(instances.bufferName(), 1);
+			.addAttribs<LocationVertex, &LocationVertex::front, &LocationVertex::frontPos>(instances.bufferName(), 1);
 	bogies.back()
 			->configureVAO(instancesBogiesVAO.back())
-			.addAttribs<LocationVertex, &LocationVertex::back>(instances.bufferName(), 1);
+			.addAttribs<LocationVertex, &LocationVertex::back, &LocationVertex::backPos>(instances.bufferName(), 1);
+	static_assert(sizeof(LocationVertex) == 228UL);
 }
 
 void
diff --git a/game/vehicles/railVehicleClass.h b/game/vehicles/railVehicleClass.h
index 4668d7d..16dce01 100644
--- a/game/vehicles/railVehicleClass.h
+++ b/game/vehicles/railVehicleClass.h
@@ -20,6 +20,7 @@ public:
 
 	struct LocationVertex {
 		glm::mat4 body, front, back;
+		Position3D bodyPos, frontPos, backPos;
 	};
 
 	std::array<Mesh::Ptr, 2> bogies;
diff --git a/gfx/gl/camera.cpp b/gfx/gl/camera.cpp
index 6a0359c..15f76c4 100644
--- a/gfx/gl/camera.cpp
+++ b/gfx/gl/camera.cpp
@@ -8,10 +8,9 @@
 
 Camera::Camera(Position3D pos, Angle fov, Angle aspect, Distance zNear, Distance zFar) :
 	position {pos}, forward {::north}, up {::up}, near {zNear}, far {zFar},
-	projection {glm::perspective(fov, aspect, zNear, zFar)},
-	viewProjection {projection * glm::lookAt(position, position + forward, up)},
-	inverseViewProjection {glm::inverse(viewProjection)}
+	projection {glm::perspective(fov, aspect, zNear, zFar)}, viewProjection {}, inverseViewProjection {}
 {
+	updateView();
 }
 
 Ray
@@ -25,8 +24,8 @@ Camera::unProject(const ScreenRelCoord & mouse) const
 void
 Camera::updateView()
 {
-	viewProjection = projection * glm::lookAt(position, position + forward, up);
-	inverseViewProjection = glm::inverse(viewProjection);
+	viewProjection = projection * glm::lookAt(origin, forward, up);
+	inverseViewProjection = glm::inverse(projection * glm::lookAt(position, position + forward, up));
 }
 
 Direction3D
diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index 4a3fec9..9b5510e 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -52,7 +52,7 @@ SceneRenderer::SceneRenderer(ScreenAbsCoord s, GLuint o) :
 void
 SceneRenderer::render(const SceneProvider & scene) const
 {
-	shader.setViewProjection(camera.getViewProjection());
+	shader.setViewProjection(camera.getPosition(), camera.getViewProjection());
 	glViewport(0, 0, size.x, size.y);
 
 	// Geometry pass
diff --git a/gfx/gl/sceneShader.cpp b/gfx/gl/sceneShader.cpp
index 2dc2e70..2f391fd 100644
--- a/gfx/gl/sceneShader.cpp
+++ b/gfx/gl/sceneShader.cpp
@@ -26,11 +26,11 @@ SceneShader::SceneShader() :
 }
 
 void
-SceneShader::setViewProjection(const glm::mat4 & viewProjection) const
+SceneShader::setViewProjection(const Position3D & viewPoint, const glm::mat4 & viewProjection) const
 {
 	for (const auto & prog : std::array<const SceneProgram *, 7> {
 				 &basic, &basicInst, &water, &landmass, &absolute, &pointLight, &spotLight}) {
-		prog->setViewProjection(viewProjection);
+		prog->setViewProjection(viewPoint, viewProjection);
 	}
 }
 
@@ -44,10 +44,11 @@ SceneShader::setViewPort(const ViewPort & viewPort) const
 }
 
 void
-SceneShader::SceneProgram::setViewProjection(const glm::mat4 & viewProjection) const
+SceneShader::SceneProgram::setViewProjection(const Position3D & viewPoint, const glm::mat4 & viewProjection) const
 {
 	glUseProgram(*this);
 	glUniformMatrix4fv(viewProjectionLoc, 1, GL_FALSE, glm::value_ptr(viewProjection));
+	glUniform3fv(viewPointLoc, 1, glm::value_ptr(viewPoint));
 }
 
 void
@@ -86,7 +87,8 @@ SceneShader::WaterProgram::use(float waveCycle) const
 }
 
 SceneShader::PointLightShader::PointLightShader() :
-	SceneProgram {pointLight_vs, pointLight_gs, pointLight_fs}, colourLoc {*this, "colour"}, kqLoc {*this, "kq"}
+	SceneProgram {pointLight_vs, pointLight_gs, pointLight_fs}, colourLoc {*this, "colour"}, kqLoc {*this, "kq"},
+	viewPointLoc {*this, "viewPoint"}
 {
 	VertexArrayObject {va}.addAttribs<Position3D>(b);
 }
@@ -105,7 +107,8 @@ SceneShader::PointLightShader::add(const Position3D & position, const RGB & colo
 
 SceneShader::SpotLightShader::SpotLightShader() :
 	SceneProgram {spotLight_vs, spotLight_gs, spotLight_fs}, directionLoc {*this, "v_direction"},
-	colourLoc {*this, "colour"}, kqLoc {*this, "kq"}, arcLoc {*this, "arc"}
+	colourLoc {*this, "colour"}, kqLoc {*this, "kq"}, arcLoc {*this, "arc"}, viewPointLoc {*this, "viewPoint"}
+
 {
 	using v3pair = std::pair<Position3D, Direction3D>;
 	VertexArrayObject {va}.addAttribs<v3pair, &v3pair::first, &v3pair::second>(b);
diff --git a/gfx/gl/sceneShader.h b/gfx/gl/sceneShader.h
index f46b842..154dc17 100644
--- a/gfx/gl/sceneShader.h
+++ b/gfx/gl/sceneShader.h
@@ -11,15 +11,16 @@ class SceneShader {
 	public:
 		template<typename... S>
 		inline explicit SceneProgram(const S &... srcs) :
-			Program {srcs...}, viewProjectionLoc {*this, "viewProjection"}, viewPortLoc {*this, "viewPort"}
+			Program {srcs...}, viewProjectionLoc {*this, "viewProjection"}, viewPointLoc {*this, "viewPoint"},
+			viewPortLoc {*this, "viewPort"}
 		{
 		}
 
-		void setViewProjection(const glm::mat4 &) const;
+		void setViewProjection(const Position3D &, const glm::mat4 &) const;
 		void setViewPort(const ViewPort &) const;
 
 	private:
-		RequiredUniformLocation viewProjectionLoc;
+		RequiredUniformLocation viewProjectionLoc, viewPointLoc;
 		UniformLocation viewPortLoc;
 	};
 
@@ -58,6 +59,7 @@ class SceneShader {
 	private:
 		UniformLocation colourLoc;
 		UniformLocation kqLoc;
+		UniformLocation viewPointLoc;
 		glVertexArray va;
 		glBuffer b;
 	};
@@ -74,6 +76,7 @@ class SceneShader {
 		UniformLocation colourLoc;
 		UniformLocation kqLoc;
 		UniformLocation arcLoc;
+		UniformLocation viewPointLoc;
 		glVertexArray va;
 		glBuffer b;
 	};
@@ -87,6 +90,6 @@ public:
 	PointLightShader pointLight;
 	SpotLightShader spotLight;
 
-	void setViewProjection(const glm::mat4 & viewProjection) const;
+	void setViewProjection(const Position3D & viewPoint, const glm::mat4 & viewProjection) const;
 	void setViewPort(const ViewPort & viewPort) const;
 };
diff --git a/gfx/gl/shaders/commonPoint.glsl b/gfx/gl/shaders/commonPoint.glsl
index 35510e1..046da27 100644
--- a/gfx/gl/shaders/commonPoint.glsl
+++ b/gfx/gl/shaders/commonPoint.glsl
@@ -24,5 +24,5 @@ main()
 	Colour = colour;
 	Material = getMaterialDetail(material);
 
-	gl_Position = viewProjection * worldPos;
+	gl_Position = viewProjection * vec4(FragPos - viewPoint + modelPos, 1);
 }
diff --git a/gfx/gl/shaders/commonShadowPoint.glsl b/gfx/gl/shaders/commonShadowPoint.glsl
index c7cbd3e..216642e 100644
--- a/gfx/gl/shaders/commonShadowPoint.glsl
+++ b/gfx/gl/shaders/commonShadowPoint.glsl
@@ -1,6 +1,7 @@
 void
 main()
 {
-	gl_Position = viewProjection * model * vec4(position, 1.0);
+	vec4 worldPos = model * vec4(position, 1.0);
+	gl_Position = viewProjection * vec4(worldPos.xyz - viewPoint + modelPos, 1);
 	gl_Position.z = max(gl_Position.z, -1);
 }
diff --git a/gfx/gl/shaders/dynamicPoint.vs b/gfx/gl/shaders/dynamicPoint.vs
index 961535c..9dd6a47 100644
--- a/gfx/gl/shaders/dynamicPoint.vs
+++ b/gfx/gl/shaders/dynamicPoint.vs
@@ -5,6 +5,8 @@ include(`meshIn.glsl')
 include(`materialInterface.glsl')
 
 uniform mat4 viewProjection;
+uniform vec3 viewPoint;
 uniform mat4 model;
+uniform vec3 modelPos;
 
 include(`commonPoint.glsl')
diff --git a/gfx/gl/shaders/dynamicPointInst.vs b/gfx/gl/shaders/dynamicPointInst.vs
index 2d6cee5..4ae6813 100644
--- a/gfx/gl/shaders/dynamicPointInst.vs
+++ b/gfx/gl/shaders/dynamicPointInst.vs
@@ -5,6 +5,8 @@ include(`meshIn.glsl')
 include(`materialInterface.glsl')
 
 uniform mat4 viewProjection;
+uniform vec3 viewPoint;
 layout(location = 5) in mat4 model;
+layout(location = 9) in vec3 modelPos;
 
 include(`commonPoint.glsl')
diff --git a/gfx/gl/shaders/fixedPoint.vs b/gfx/gl/shaders/fixedPoint.vs
index ed78c96..0adbb02 100644
--- a/gfx/gl/shaders/fixedPoint.vs
+++ b/gfx/gl/shaders/fixedPoint.vs
@@ -5,6 +5,8 @@ include(`meshIn.glsl')
 include(`materialInterface.glsl')
 
 uniform mat4 viewProjection;
+uniform vec3 viewPoint;
 const mat4 model = mat4(1);
+const vec3 modelPos = vec3(0);
 
 include(`commonPoint.glsl')
diff --git a/gfx/gl/shaders/pointLight.gs b/gfx/gl/shaders/pointLight.gs
index 03d131d..ec089f5 100644
--- a/gfx/gl/shaders/pointLight.gs
+++ b/gfx/gl/shaders/pointLight.gs
@@ -19,6 +19,7 @@ const vec3[] cube = vec3[]( // http://www.cs.umd.edu/gvil/papers/av_ts.pdf
 		vec3(1, 1, -1) // Back-top-right
 );
 uniform mat4 viewProjection;
+uniform vec3 viewPoint;
 
 in vec3 centre[];
 in float size[];
diff --git a/gfx/gl/shaders/pointLight.vs b/gfx/gl/shaders/pointLight.vs
index 35682fa..b3fe7b9 100644
--- a/gfx/gl/shaders/pointLight.vs
+++ b/gfx/gl/shaders/pointLight.vs
@@ -4,6 +4,7 @@ layout(location = 0) in vec3 position;
 
 uniform vec3 colour;
 uniform float kq;
+uniform vec3 viewPoint;
 
 out vec3 centre;
 out float size;
@@ -13,5 +14,5 @@ main()
 {
 	centre = position;
 	size = (8 * sqrt(max(max(colour.r, colour.g), colour.b))) / sqrt(kq);
-	gl_Position = vec4(centre, 0);
+	gl_Position = vec4(centre - viewPoint, 0);
 }
diff --git a/gfx/gl/shaders/shadowDynamicPoint.vs b/gfx/gl/shaders/shadowDynamicPoint.vs
index f3ed533..eb25423 100644
--- a/gfx/gl/shaders/shadowDynamicPoint.vs
+++ b/gfx/gl/shaders/shadowDynamicPoint.vs
@@ -3,6 +3,8 @@
 include(`meshIn.glsl')
 
 uniform mat4 viewProjection;
+uniform vec3 viewPoint;
 uniform mat4 model;
+uniform vec3 modelPos;
 
 include(`commonShadowPoint.glsl')
diff --git a/gfx/gl/shaders/shadowDynamicPointInst.vs b/gfx/gl/shaders/shadowDynamicPointInst.vs
index 1bf74ef..a0f51c3 100644
--- a/gfx/gl/shaders/shadowDynamicPointInst.vs
+++ b/gfx/gl/shaders/shadowDynamicPointInst.vs
@@ -3,6 +3,8 @@
 include(`meshIn.glsl')
 
 uniform mat4 viewProjection;
+uniform vec3 viewPoint;
 layout(location = 5) in mat4 model;
+layout(location = 9) in vec3 modelPos;
 
 include(`commonShadowPoint.glsl')
diff --git a/gfx/gl/shaders/shadowFixedPoint.vs b/gfx/gl/shaders/shadowFixedPoint.vs
index 8921707..dfc5c42 100644
--- a/gfx/gl/shaders/shadowFixedPoint.vs
+++ b/gfx/gl/shaders/shadowFixedPoint.vs
@@ -3,6 +3,8 @@
 include(`meshIn.glsl')
 
 uniform mat4 viewProjection;
+uniform vec3 viewPoint;
 const mat4 model = mat4(1);
+const vec3 modelPos = vec3(0);
 
 include(`commonShadowPoint.glsl')
diff --git a/gfx/gl/shaders/spotLight.gs b/gfx/gl/shaders/spotLight.gs
index ad65675..0529614 100644
--- a/gfx/gl/shaders/spotLight.gs
+++ b/gfx/gl/shaders/spotLight.gs
@@ -10,6 +10,7 @@ const vec3[] pyramid = vec3[]( // four-sided
 		vec3(1, -1, 1) // Front-right
 );
 uniform mat4 viewProjection;
+uniform vec3 viewPoint;
 uniform float arc;
 
 in vec3 position[];
diff --git a/gfx/gl/shaders/spotLight.vs b/gfx/gl/shaders/spotLight.vs
index dca0854..e61b641 100644
--- a/gfx/gl/shaders/spotLight.vs
+++ b/gfx/gl/shaders/spotLight.vs
@@ -6,6 +6,7 @@ uniform vec3 v_direction;
 uniform vec3 colour;
 uniform float kq;
 uniform float arc;
+uniform vec3 viewPoint;
 
 out vec3 position;
 out vec3 direction;
@@ -19,5 +20,5 @@ main()
 	direction = normalize(v_direction);
 	size = (8 * sqrt(max(max(colour.r, colour.g), colour.b))) / sqrt(kq);
 	cosarc = cos(arc / 2);
-	gl_Position = vec4(position, 0);
+	gl_Position = vec4(position - viewPoint, 0);
 }
diff --git a/gfx/gl/shaders/water.vs b/gfx/gl/shaders/water.vs
index a21b49f..014499f 100644
--- a/gfx/gl/shaders/water.vs
+++ b/gfx/gl/shaders/water.vs
@@ -4,17 +4,18 @@ include(`meshIn.glsl')
 include(`materialInterface.glsl')
 
 uniform mat4 viewProjection;
+uniform vec3 viewPoint;
 uniform vec3 waves;
 
 void
 main()
 {
-	vec4 wpos = vec4(position.x + cos(waves.x), position.y + cos(waves.x * waves.y / 2),
-			cos(waves.x + position.x + (position.y / 8)) * .3, 1.0);
+	vec3 wpos = vec3(position.x + cos(waves.x), position.y + cos(waves.x * waves.y / 2),
+			cos(waves.x + position.x + (position.y / 8)) * .3);
 
 	FragPos = vec3(wpos.xy, position.z);
 	TexCoords = texCoord;
 	Normal = normal;
 
-	gl_Position = viewProjection * wpos;
+	gl_Position = viewProjection * vec4(wpos - viewPoint, 1.0);
 }
-- 
cgit v1.2.3


From 685b33980cc7a346574b24732464f0cbe3115a1f Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Wed, 15 Nov 2023 01:29:24 +0000
Subject: Switch to millimeters for spatial units

Mostly a case of changing far too many magic numbers, something else to
fix I guess. I probably missed something. Also there's some hackery when
loading 3D models, which are still assumed to be in metres.
---
 application/main.cpp          | 17 +++++++++--------
 assetFactory/factoryMesh.cpp  |  2 +-
 game/geoData.cpp              |  2 +-
 game/geoData.h                |  2 +-
 game/network/rail.cpp         | 18 +++++++++---------
 game/vehicles/linkHistory.cpp |  2 +-
 game/vehicles/railVehicle.cpp |  4 ++--
 gfx/gl/sceneRenderer.cpp      |  2 +-
 gfx/gl/shaders/landmass.fs    |  6 +++---
 gfx/gl/shaders/pointLight.fs  |  2 +-
 gfx/gl/shaders/pointLight.vs  |  2 +-
 gfx/gl/shaders/spotLight.fs   |  2 +-
 gfx/gl/shaders/spotLight.vs   |  2 +-
 gfx/gl/shaders/water.fs       |  2 +-
 gfx/gl/shaders/water.vs       |  4 ++--
 gfx/gl/shadowMapper.cpp       | 10 +++++-----
 res/brush47.xml               |  2 +-
 test/test-assetFactory.cpp    | 14 +++++++-------
 test/test-geo.cpp             | 10 +++++-----
 test/test-render.cpp          | 26 +++++++++++++-------------
 ui/gameMainWindow.cpp         |  2 +-
 ui/manualCameraController.cpp |  4 ++--
 ui/manualCameraController.h   |  2 +-
 23 files changed, 70 insertions(+), 69 deletions(-)

(limited to 'game')

diff --git a/application/main.cpp b/application/main.cpp
index ffdaf63..01e6561 100644
--- a/application/main.cpp
+++ b/application/main.cpp
@@ -37,7 +37,7 @@ public:
 	int
 	run()
 	{
-		geoData = std::make_shared<GeoData>(GeoData::Limits {{-120, -120}, {120, 120}}, 10.F);
+		geoData = std::make_shared<GeoData>(GeoData::Limits {{-120, -120}, {120, 120}}, 10000.F);
 		geoData->generateRandom();
 
 		Windows windows;
@@ -48,10 +48,10 @@ public:
 
 		{
 			auto rl = world.create<RailLinks>();
-			const Position3D j {-1120, -1100, 3}, k {-1100, -1000, 15}, l {-1000, -800, 20}, m {-900, -600, 30},
-					n {-600, -500, 32}, o {-500, -800, 30}, p {-600, -900, 25}, q {-1025, -1175, 10},
-					r {-925, -1075, 10};
-			const Position3D s {-1100, -500, 15}, t {-1100, -450, 15}, u {-1000, -400, 15};
+			const Position3D j {-1120000, -1100000, 3000}, k {-1100000, -1000000, 15000}, l {-1000000, -800000, 20000},
+					m {-900000, -600000, 30000}, n {-600000, -500000, 32000}, o {-500000, -800000, 30000},
+					p {-600000, -900000, 25000}, q {-1025000, -1175000, 10000}, r {-925000, -1075000, 10000};
+			const Position3D s {-1100000, -500000, 15000}, t {-1100000, -450000, 15000}, u {-1000000, -400000, 15000};
 			auto l3 = rl->addLinksBetween(j, k);
 			rl->addLinksBetween(k, l);
 			rl->addLinksBetween(l, m);
@@ -75,12 +75,13 @@ public:
 				train->create<RailVehicle>(b47);
 			}
 			train->orders.removeAll();
-			train->orders.create<GoTo>(&train->orders, l3->ends[1], l3->length, rl->findNodeAt({-1100, -450, 15}));
+			train->orders.create<GoTo>(
+					&train->orders, l3->ends[1], l3->length, rl->findNodeAt({-1100000, -450000, 15000}));
 			train->currentActivity = train->orders.current()->createActivity();
 
 			auto foliage = std::dynamic_pointer_cast<Foliage>(assets.at("Tree-01-1"));
-			for (float x = 900; x < 1100; x += 3) {
-				for (float y = 900; y < 1100; y += 3) {
+			for (float x = 900000; x < 1100000; x += 3000) {
+				for (float y = 900000; y < 1100000; y += 3000) {
 					world.create<Plant>(foliage, Location {geoData->positionAt({-x, -y})});
 				}
 			}
diff --git a/assetFactory/factoryMesh.cpp b/assetFactory/factoryMesh.cpp
index 46bcf6f..3caf5e8 100644
--- a/assetFactory/factoryMesh.cpp
+++ b/assetFactory/factoryMesh.cpp
@@ -30,7 +30,7 @@ FactoryMesh::createMesh() const
 				const auto & point = mesh.point(vertex);
 				const auto & normal = useVertexNormals ? mesh.property(mesh.vertex_normals_pph(), vertex)
 													   : mesh.property(mesh.face_normals_pph(), face);
-				Vertex outVertex {point, textureUV, normal, colour, material};
+				Vertex outVertex {point * 1000.F, textureUV, normal, colour, material};
 				if (const auto existingItr = std::find(vertices.rbegin(), vertices.rend(), outVertex);
 						existingItr != vertices.rend()) {
 					faceIndices.push_back(static_cast<unsigned int>(std::distance(existingItr, vertices.rend()) - 1));
diff --git a/game/geoData.cpp b/game/geoData.cpp
index 76550cc..da067f7 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -31,7 +31,7 @@ GeoData::generateRandom()
 	std::uniform_int_distribution<> rxpos(limit.first.x + 2, limit.second.x - 2),
 			rypos(limit.first.y + 2, limit.second.y - 2);
 	std::uniform_int_distribution<> rsize(10, 30);
-	std::uniform_real_distribution<float> rheight(1, 3);
+	std::uniform_real_distribution<float> rheight(1000, 3000);
 	for (int h = 0; h < 500;) {
 		const glm::ivec2 hpos {rxpos(gen), rypos(gen)};
 		const glm::ivec2 hsize {rsize(gen), rsize(gen)};
diff --git a/game/geoData.h b/game/geoData.h
index b3ec51d..3bceb9c 100644
--- a/game/geoData.h
+++ b/game/geoData.h
@@ -14,7 +14,7 @@ class Ray;
 class GeoData {
 public:
 	struct Node {
-		float height {-1.5F};
+		float height {-1500.F};
 	};
 
 	using Quad = std::array<Position3D, 4>;
diff --git a/game/network/rail.cpp b/game/network/rail.cpp
index cc61db9..ff101d4 100644
--- a/game/network/rail.cpp
+++ b/game/network/rail.cpp
@@ -18,7 +18,7 @@
 template class NetworkOf<RailLink>;
 
 constexpr auto RAIL_CROSSSECTION_VERTICES {5U};
-constexpr Size3D RAIL_HEIGHT {0, 0, .25F};
+constexpr Size3D RAIL_HEIGHT {0, 0, 250.F};
 
 RailLinks::RailLinks() : NetworkOf<RailLink> {"rails.jpg"} { }
 
@@ -104,11 +104,11 @@ constexpr const std::array<std::pair<Position3D, float>, RAIL_CROSSSECTION_VERTI
 		//   ___________
 		// _/           \_
 		//  left to right
-		{{-1.9F, 0.F, 0.F}, 0.F},
-		{{-.608F, 0.F, RAIL_HEIGHT.z}, 0.34F},
-		{{0, 0.F, RAIL_HEIGHT.z * .7F}, 0.5F},
-		{{.608F, 0.F, RAIL_HEIGHT.z}, 0.66F},
-		{{1.9F, 0.F, 0.F}, 1.F},
+		{{-1900.F, 0.F, 0.F}, 0.F},
+		{{-608.F, 0.F, RAIL_HEIGHT.z}, .34F},
+		{{0, 0.F, RAIL_HEIGHT.z * .7F}, .5F},
+		{{608.F, 0.F, RAIL_HEIGHT.z}, .66F},
+		{{1900.F, 0.F, 0.F}, 1.F},
 }};
 constexpr auto sleepers {5.F}; // There are 5 repetitions of sleepers in the texture
 
@@ -128,7 +128,7 @@ RailLinkStraight::RailLinkStraight(Node::Ptr a, Node::Ptr b, const Position3D &
 	if (glGenVertexArrays) {
 		std::vector<Vertex> vertices;
 		vertices.reserve(2 * railCrossSection.size());
-		const auto len = round_sleepers(length / 2.F);
+		const auto len = round_sleepers(length / 2000.F);
 		const auto e {flat_orientation(diff)};
 		for (auto ei : {1U, 0U}) {
 			const auto trans {glm::translate(ends[ei].node->pos) * e};
@@ -155,8 +155,8 @@ RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, Position3
 		const auto & e0p {ends[0].node->pos};
 		const auto & e1p {ends[1].node->pos};
 		const auto slength = round_sleepers(length / 2.F);
-		const auto segs = std::round(15.F * slength / std::pow(radius, 0.7F));
-		const auto step {Position3D {arc_length(arc), e1p.z - e0p.z, slength} / segs};
+		const auto segs = std::round(slength / std::pow(radius, 0.7F));
+		const auto step {Position3D {arc_length(arc), e1p.z - e0p.z, slength / 1000.F} / segs};
 		const auto trans {glm::translate(centreBase)};
 
 		auto segCount = static_cast<std::size_t>(std::lround(segs)) + 1;
diff --git a/game/vehicles/linkHistory.cpp b/game/vehicles/linkHistory.cpp
index 2802109..e6bab36 100644
--- a/game/vehicles/linkHistory.cpp
+++ b/game/vehicles/linkHistory.cpp
@@ -8,7 +8,7 @@ LinkHistory::add(const Link::WPtr & l, unsigned char d)
 	links.insert(links.begin(), {l, d});
 	const auto lp = l.lock();
 	totalLen += lp->length;
-	while (totalLen >= 1000.F && !links.empty()) {
+	while (totalLen >= 1000000.F && !links.empty()) {
 		totalLen -= links.back().first.lock()->length;
 		links.pop_back();
 	}
diff --git a/game/vehicles/railVehicle.cpp b/game/vehicles/railVehicle.cpp
index 6e6e18f..26536f5 100644
--- a/game/vehicles/railVehicle.cpp
+++ b/game/vehicles/railVehicle.cpp
@@ -46,9 +46,9 @@ RailVehicle::move(const Train * t, float & trailBy)
 bool
 RailVehicle::intersectRay(const Ray & ray, Position2D * baryPos, float * distance) const
 {
-	constexpr const auto X = 1.35F;
+	constexpr const auto X = 1350.F;
 	const auto Y = this->rvClass->length / 2.F;
-	constexpr const auto Z = 3.9F;
+	constexpr const auto Z = 3900.F;
 	const auto moveBy = location.getTransform();
 	const std::array<Position3D, 8> cornerVertices {{
 			moveBy * glm::vec4 {-X, Y, 0, 1}, //  LFB
diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index 9b5510e..53178e5 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -15,7 +15,7 @@ static constexpr const std::array<const glm::i8vec4, 4> displayVAOdata {{
 }};
 
 SceneRenderer::SceneRenderer(ScreenAbsCoord s, GLuint o) :
-	camera {{-1250.0F, -1250.0F, 35.0F}, quarter_pi, ratio(s), 0.1F, 10000.0F}, size {s}, output {o},
+	camera {{-1250000.0F, -1250000.0F, 35.0F}, quarter_pi, ratio(s), 100.F, 10000000.0F}, size {s}, output {o},
 	lighting {lighting_vs, lighting_fs}, shadowMapper {{2048, 2048}}
 {
 	shader.setViewPort({0, 0, size.x, size.y});
diff --git a/gfx/gl/shaders/landmass.fs b/gfx/gl/shaders/landmass.fs
index 4dc92bb..9865d11 100644
--- a/gfx/gl/shaders/landmass.fs
+++ b/gfx/gl/shaders/landmass.fs
@@ -11,9 +11,9 @@ const vec3 rock = vec3(.2, .2, .1);
 const vec3 sand = vec3(.76, .7, .5);
 const vec3 snow = vec3(.97, .97, .99);
 
-const float beachline = .5;
-const float snowline_low = 28;
-const float snowline_high = 30;
+const float beachline = 500;
+const float snowline_low = 28000;
+const float snowline_high = 30000;
 
 const float slope_min = .99;
 const float slope_mid = .95;
diff --git a/gfx/gl/shaders/pointLight.fs b/gfx/gl/shaders/pointLight.fs
index bd32c05..1a68df8 100644
--- a/gfx/gl/shaders/pointLight.fs
+++ b/gfx/gl/shaders/pointLight.fs
@@ -26,5 +26,5 @@ main()
 	if (normalDot < 0) {
 		discard;
 	}
-	FragColor = (colour * normalDot) / (1 + (kq * pow(lightDist, 2)));
+	FragColor = (colour * normalDot) / (1 + (kq * pow(lightDist / 1000.0, 2)));
 }
diff --git a/gfx/gl/shaders/pointLight.vs b/gfx/gl/shaders/pointLight.vs
index b3fe7b9..7694a25 100644
--- a/gfx/gl/shaders/pointLight.vs
+++ b/gfx/gl/shaders/pointLight.vs
@@ -13,6 +13,6 @@ void
 main()
 {
 	centre = position;
-	size = (8 * sqrt(max(max(colour.r, colour.g), colour.b))) / sqrt(kq);
+	size = (8000 * sqrt(max(max(colour.r, colour.g), colour.b))) / sqrt(kq);
 	gl_Position = vec4(centre - viewPoint, 0);
 }
diff --git a/gfx/gl/shaders/spotLight.fs b/gfx/gl/shaders/spotLight.fs
index add86fd..78b8f72 100644
--- a/gfx/gl/shaders/spotLight.fs
+++ b/gfx/gl/shaders/spotLight.fs
@@ -30,5 +30,5 @@ main()
 	if (normalDot < 0) {
 		discard;
 	}
-	FragColor = (colour * normalDot) / (1 + (kq * pow(lightDist, 2)));
+	FragColor = (colour * normalDot) / (1 + (kq * pow(lightDist / 1000.0, 2)));
 }
diff --git a/gfx/gl/shaders/spotLight.vs b/gfx/gl/shaders/spotLight.vs
index e61b641..08197a4 100644
--- a/gfx/gl/shaders/spotLight.vs
+++ b/gfx/gl/shaders/spotLight.vs
@@ -18,7 +18,7 @@ main()
 {
 	position = v_position;
 	direction = normalize(v_direction);
-	size = (8 * sqrt(max(max(colour.r, colour.g), colour.b))) / sqrt(kq);
+	size = (8000 * sqrt(max(max(colour.r, colour.g), colour.b))) / sqrt(kq);
 	cosarc = cos(arc / 2);
 	gl_Position = vec4(position - viewPoint, 0);
 }
diff --git a/gfx/gl/shaders/water.fs b/gfx/gl/shaders/water.fs
index 04aa94c..2ccc924 100644
--- a/gfx/gl/shaders/water.fs
+++ b/gfx/gl/shaders/water.fs
@@ -13,5 +13,5 @@ main()
 	gPosition = vec4(FragPos, 1);
 	gNormal = vec4(Normal, 1);
 	gAlbedoSpec = texture(texture0, TexCoords);
-	gAlbedoSpec.a *= clamp(-FragPos.z * .7, .1, 1.0);
+	gAlbedoSpec.a *= clamp(-FragPos.z * .0007, .1, 1.0);
 }
diff --git a/gfx/gl/shaders/water.vs b/gfx/gl/shaders/water.vs
index 014499f..03eabb2 100644
--- a/gfx/gl/shaders/water.vs
+++ b/gfx/gl/shaders/water.vs
@@ -10,8 +10,8 @@ uniform vec3 waves;
 void
 main()
 {
-	vec3 wpos = vec3(position.x + cos(waves.x), position.y + cos(waves.x * waves.y / 2),
-			cos(waves.x + position.x + (position.y / 8)) * .3);
+	vec3 wpos = vec3(position.x + (cos(waves.x) * 1000.0), position.y + (cos(waves.x * waves.y / 2) * 1000.0),
+			cos(waves.x + (position.x / 1000.0) + (position.y * 125.0)) * 300.0);
 
 	FragPos = vec3(wpos.xy, position.z);
 	TexCoords = texCoord;
diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index e4ee47a..190f20e 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -80,11 +80,11 @@ constexpr std::array<std::array<TextureRelRegion, ShadowMapper::SHADOW_BANDS>, S
 				}},
 		}};
 constexpr std::array<float, ShadowMapper::SHADOW_BANDS + 1> shadowBands {
-		1.F,
-		250.F,
-		750.F,
-		2500.F,
-		10000.F,
+		1000.F,
+		250000.F,
+		750000.F,
+		2500000.F,
+		10000000.F,
 };
 static_assert(viewports.size() == shadowMapRegions.size());
 static_assert(shadowBands.size() == shadowMapRegions.size() + 1);
diff --git a/res/brush47.xml b/res/brush47.xml
index 31518c8..dc33282 100644
--- a/res/brush47.xml
+++ b/res/brush47.xml
@@ -61,7 +61,7 @@
   <textureFragment id="roofSideWithVents" path="rail/roofSideWithVents.png"/>
   <textureFragment id="roofTopWithVents" path="rail/roofTopWithVents.png"/>
   <textureFragment id="cabWindowFront" path="rail/cabWindowFront.png"/>
-  <asset p.typeid="RailVehicleClass" id="brush-47" name="Brush 47" length="19.38" wheelBase="15.70" maxSpeed="42.4688">
+  <asset p.typeid="RailVehicleClass" id="brush-47" name="Brush 47" length="19380" wheelBase="15700" maxSpeed="42468.8">
     <bodyMesh id="body" size="2.69,19.38,3.9">
       <use type="cuboid" position="0,0,1.2" scale="2.69,19.38,0.3" colour="goldenrod">
         <face id="bottom" colour="#2c3539"/>
diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 9af08cb..c8183df 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -64,7 +64,7 @@ public:
 	}
 
 	void
-	render(float dist = 10.f)
+	render(float dist)
 	{
 		sceneRenderer.camera.setView({-dist, dist * 1.2f, dist * 1.2f}, south + east + down);
 		sceneRenderer.render(*this);
@@ -104,7 +104,7 @@ BOOST_AUTO_TEST_CASE(brush47xml, *boost::unit_test::timeout(5))
 	auto railVehicle = std::make_shared<RailVehicle>(brush47rvc);
 	objects.objects.push_back(brush47rvc);
 
-	render();
+	render(10000);
 }
 
 BOOST_AUTO_TEST_CASE(foliage, *boost::unit_test::timeout(5))
@@ -116,13 +116,13 @@ BOOST_AUTO_TEST_CASE(foliage, *boost::unit_test::timeout(5))
 	auto tree_01_1_f = std::dynamic_pointer_cast<Foliage>(tree_01_1);
 	BOOST_REQUIRE(tree_01_1_f);
 
-	auto plant1 = std::make_shared<Plant>(tree_01_1_f, Location {{-2, 2, 0}, {0, 0, 0}});
-	auto plant2 = std::make_shared<Plant>(tree_01_1_f, Location {{3, -4, 0}, {0, 1, 0}});
-	auto plant3 = std::make_shared<Plant>(tree_01_1_f, Location {{-2, -4, 0}, {0, 2, 0}});
-	auto plant4 = std::make_shared<Plant>(tree_01_1_f, Location {{3, 2, 0}, {0, 3, 0}});
+	auto plant1 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, 2000, 0}, {0, 0, 0}});
+	auto plant2 = std::make_shared<Plant>(tree_01_1_f, Location {{3000, -4000, 0}, {0, 1, 0}});
+	auto plant3 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, -4000, 0}, {0, 2, 0}});
+	auto plant4 = std::make_shared<Plant>(tree_01_1_f, Location {{3000, 2000, 0}, {0, 3, 0}});
 	objects.objects.push_back(tree_01_1_f);
 
-	render(5);
+	render(6000);
 }
 
 BOOST_AUTO_TEST_SUITE_END();
diff --git a/test/test-geo.cpp b/test/test-geo.cpp
index 9874fb7..7404d32 100644
--- a/test/test-geo.cpp
+++ b/test/test-geo.cpp
@@ -30,7 +30,7 @@ BOOST_AUTO_TEST_CASE(initialize)
 	BOOST_CHECK_EQUAL(size, glm::uvec2(41, 46));
 	BOOST_CHECK_EQUAL(nodes.size(), 1886);
 	BOOST_CHECK(std::all_of(nodes.begin(), nodes.end(), [](const auto & n) {
-		return n.height == -1.5F;
+		return n.height == -1500.F;
 	}));
 }
 
@@ -63,12 +63,12 @@ BOOST_AUTO_TEST_CASE(gen_random)
 	}));
 	// Still an island
 	for (int x = limit.first.x; x <= limit.second.x; x += 1) {
-		BOOST_CHECK_EQUAL(nodes[at(x, limit.first.y)].height, -1.5F);
-		BOOST_CHECK_EQUAL(nodes[at(x, limit.second.y)].height, -1.5F);
+		BOOST_CHECK_EQUAL(nodes[at(x, limit.first.y)].height, -1500.F);
+		BOOST_CHECK_EQUAL(nodes[at(x, limit.second.y)].height, -1500.F);
 	}
 	for (int y = limit.first.y; y <= limit.second.y; y += 1) {
-		BOOST_CHECK_EQUAL(nodes[at(limit.first.x, y)].height, -1.5F);
-		BOOST_CHECK_EQUAL(nodes[at(limit.second.x, y)].height, -1.5F);
+		BOOST_CHECK_EQUAL(nodes[at(limit.first.x, y)].height, -1500.F);
+		BOOST_CHECK_EQUAL(nodes[at(limit.second.x, y)].height, -1500.F);
 	}
 }
 
diff --git a/test/test-render.cpp b/test/test-render.cpp
index b16f241..766bb74 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -26,7 +26,7 @@ class TestScene : public SceneProvider {
 	std::shared_ptr<RailVehicle> train1, train2;
 
 	Terrain terrain {[]() {
-		auto gd = std::make_shared<GeoData>(GeoData::Limits {{0, 0}, {100, 100}});
+		auto gd = std::make_shared<GeoData>(GeoData::Limits {{0, 0}, {100, 100}}, 10000);
 		gd->generateRandom();
 		return gd;
 	}()};
@@ -35,11 +35,11 @@ public:
 	TestScene()
 	{
 		train1 = std::make_shared<RailVehicle>(brush47rvc);
-		train1->location.setPosition({52, 50, 2});
+		train1->location.setPosition({52000, 50000, 2000});
 		train1->bogies.front().setPosition(train1->bogies.front().position() + train1->location.position());
 		train1->bogies.back().setPosition(train1->bogies.back().position() + train1->location.position());
 		train2 = std::make_shared<RailVehicle>(brush47rvc);
-		train2->location.setPosition({52, 30, 2});
+		train2->location.setPosition({52000, 30000, 2000});
 		train2->bogies.front().setPosition(train2->bogies.front().position() + train2->location.position());
 		train2->bogies.back().setPosition(train2->bogies.back().position() + train2->location.position());
 	}
@@ -88,7 +88,7 @@ BOOST_FIXTURE_TEST_SUITE(w, TestRenderOutput);
 BOOST_AUTO_TEST_CASE(basic)
 {
 	SceneRenderer ss {size, output};
-	ss.camera.setView({-10, -10, 60}, glm::normalize(glm::vec3 {1, 1, -0.5F}));
+	ss.camera.setView({-10000, -10000, 60000}, glm::normalize(glm::vec3 {1, 1, -0.5F}));
 	const TestScene scene;
 	ss.render(scene);
 	Texture::save(outImage, "/tmp/basic.tga");
@@ -97,7 +97,7 @@ BOOST_AUTO_TEST_CASE(basic)
 BOOST_AUTO_TEST_CASE(pointlight)
 {
 	SceneRenderer ss {size, output};
-	ss.camera.setView({-10, -10, 60}, glm::normalize(glm::vec3 {1, 1, -0.5F}));
+	ss.camera.setView({-10000, -10000, 60000}, glm::normalize(glm::vec3 {1, 1, -0.5F}));
 
 	class PointLightScene : public TestScene {
 	public:
@@ -111,9 +111,9 @@ BOOST_AUTO_TEST_CASE(pointlight)
 		void
 		lights(const SceneShader & shader) const override
 		{
-			for (int x = 50; x < 100; x += 20) {
-				for (int y = 50; y < 2000; y += 20) {
-					shader.pointLight.add({x, y, 4}, {1.0, 1.0, 1.0}, 0.1F);
+			for (int x = 50000; x < 100000; x += 20000) {
+				for (int y = 50000; y < 2000000; y += 20000) {
+					shader.pointLight.add({x, y, 4000}, {1.0, 1.0, 1.0}, 0.1F);
 				}
 			}
 		}
@@ -127,7 +127,7 @@ BOOST_AUTO_TEST_CASE(pointlight)
 BOOST_AUTO_TEST_CASE(spotlight)
 {
 	SceneRenderer ss {size, output};
-	ss.camera.setView({-10, -10, 60}, glm::normalize(glm::vec3 {1, 1, -0.5F}));
+	ss.camera.setView({-10000, -10000, 60000}, glm::normalize(glm::vec3 {1, 1, -0.5F}));
 
 	class PointLightScene : public TestScene {
 	public:
@@ -141,10 +141,10 @@ BOOST_AUTO_TEST_CASE(spotlight)
 		void
 		lights(const SceneShader & shader) const override
 		{
-			shader.spotLight.add({50, 50, 15}, down, {1.0, 1.0, 1.0}, 0.01F, 1);
-			shader.spotLight.add({51, 59.5, 1}, north, {1.0, 1.0, 1.0}, 0.001F, .5);
-			shader.spotLight.add({53, 59.5, 1}, north, {1.0, 1.0, 1.0}, 0.001F, .5);
-			shader.spotLight.add({60, 50, 3}, north + east, {1.0, 1.0, 1.0}, 0.0001F, .7F);
+			shader.spotLight.add({50000, 50000, 15000}, down, {1.0, 1.0, 1.0}, 0.01F, 1);
+			shader.spotLight.add({51000, 59500, 1000}, north, {1.0, 1.0, 1.0}, 0.001F, .5);
+			shader.spotLight.add({53000, 59500, 1000}, north, {1.0, 1.0, 1.0}, 0.001F, .5);
+			shader.spotLight.add({60000, 50000, 3000}, north + east, {1.0, 1.0, 1.0}, 0.0001F, .7F);
 		}
 	};
 
diff --git a/ui/gameMainWindow.cpp b/ui/gameMainWindow.cpp
index 15f1e07..7cf143a 100644
--- a/ui/gameMainWindow.cpp
+++ b/ui/gameMainWindow.cpp
@@ -31,7 +31,7 @@ public:
 GameMainWindow::GameMainWindow(size_t w, size_t h) :
 	Window {w, h, "I Like Trains", SDL_WINDOW_OPENGL}, SceneRenderer {Window::size, 0}
 {
-	uiComponents.create<ManualCameraController>(Position2D {-1150, -1150});
+	uiComponents.create<ManualCameraController>(Position2D {-1150000, -1150000});
 	auto gms = uiComponents.create<GameMainSelector>(&camera, ScreenAbsCoord {w, h});
 	uiComponents.create<GameMainToolbar>(gms.get());
 }
diff --git a/ui/manualCameraController.cpp b/ui/manualCameraController.cpp
index 05c1fc5..f6993a8 100644
--- a/ui/manualCameraController.cpp
+++ b/ui/manualCameraController.cpp
@@ -59,12 +59,12 @@ ManualCameraController::handleInput(const SDL_Event & e, const Position &)
 					pitch = std::clamp(pitch - 0.01F * static_cast<float>(e.motion.yrel), 0.1F, half_pi);
 				}
 				else {
-					focus += rotate_flat(-direction) * Position2D {-e.motion.xrel, e.motion.yrel};
+					focus += rotate_flat(-direction) * (Position2D {-e.motion.xrel, e.motion.yrel} * dist / 2.0F);
 				}
 			}
 			return true;
 		case SDL_MOUSEWHEEL:
-			dist = std::clamp(dist - static_cast<float>(e.wheel.y) * 4.F, 5.F, 200.F);
+			dist = std::clamp(dist - static_cast<float>(e.wheel.y) * 400.F, 5.F, 200000.F);
 			break;
 	}
 	return false;
diff --git a/ui/manualCameraController.h b/ui/manualCameraController.h
index 46655bc..1efaee1 100644
--- a/ui/manualCameraController.h
+++ b/ui/manualCameraController.h
@@ -22,5 +22,5 @@ private:
 	bool ctrl {false}, mrb {false};
 	Position2D focus;
 	float direction {quarter_pi};
-	float dist {40}, pitch {quarter_pi};
+	float dist {4000}, pitch {quarter_pi};
 };
-- 
cgit v1.2.3


From 3200eb41d60595813dca751fe15193ba0b44dddf Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 25 Nov 2023 14:32:56 +0000
Subject: Remove getTransform

---
 game/vehicles/railVehicle.cpp | 18 +++++++++---------
 gfx/gl/bufferedLocation.cpp   |  6 ------
 gfx/gl/bufferedLocation.h     |  1 -
 lib/location.cpp              |  6 ------
 lib/location.h                |  1 -
 5 files changed, 9 insertions(+), 23 deletions(-)

(limited to 'game')

diff --git a/game/vehicles/railVehicle.cpp b/game/vehicles/railVehicle.cpp
index 26536f5..bee0dd0 100644
--- a/game/vehicles/railVehicle.cpp
+++ b/game/vehicles/railVehicle.cpp
@@ -49,16 +49,16 @@ RailVehicle::intersectRay(const Ray & ray, Position2D * baryPos, float * distanc
 	constexpr const auto X = 1350.F;
 	const auto Y = this->rvClass->length / 2.F;
 	constexpr const auto Z = 3900.F;
-	const auto moveBy = location.getTransform();
+	const auto moveBy = location.getRotationTransform();
 	const std::array<Position3D, 8> cornerVertices {{
-			moveBy * glm::vec4 {-X, Y, 0, 1}, //  LFB
-			moveBy * glm::vec4 {X, Y, 0, 1}, //   RFB
-			moveBy * glm::vec4 {-X, Y, Z, 1}, //  LFT
-			moveBy * glm::vec4 {X, Y, Z, 1}, //   RFT
-			moveBy * glm::vec4 {-X, -Y, 0, 1}, // LBB
-			moveBy * glm::vec4 {X, -Y, 0, 1}, //  RBB
-			moveBy * glm::vec4 {-X, -Y, Z, 1}, // LBT
-			moveBy * glm::vec4 {X, -Y, Z, 1}, //  RBT
+			location.position() + (moveBy * glm::vec4 {-X, Y, 0, 1}).xyz(), //  LFB
+			location.position() + (moveBy * glm::vec4 {X, Y, 0, 1}).xyz(), //   RFB
+			location.position() + (moveBy * glm::vec4 {-X, Y, Z, 1}).xyz(), //  LFT
+			location.position() + (moveBy * glm::vec4 {X, Y, Z, 1}).xyz(), //   RFT
+			location.position() + (moveBy * glm::vec4 {-X, -Y, 0, 1}).xyz(), // LBB
+			location.position() + (moveBy * glm::vec4 {X, -Y, 0, 1}).xyz(), //  RBB
+			location.position() + (moveBy * glm::vec4 {-X, -Y, Z, 1}).xyz(), // LBT
+			location.position() + (moveBy * glm::vec4 {X, -Y, Z, 1}).xyz(), //  RBT
 	}};
 	static constexpr const std::array<glm::vec<3, uint8_t>, 10> triangles {{
 			// Front
diff --git a/gfx/gl/bufferedLocation.cpp b/gfx/gl/bufferedLocation.cpp
index 412e3ab..2a2e723 100644
--- a/gfx/gl/bufferedLocation.cpp
+++ b/gfx/gl/bufferedLocation.cpp
@@ -57,12 +57,6 @@ BufferedLocation::setLocation(Position3D p, Rotation3D r)
 	updateBuffer();
 }
 
-glm::mat4
-BufferedLocation::getTransform() const
-{
-	return loc.getTransform();
-}
-
 glm::mat4
 BufferedLocation::getRotationTransform() const
 {
diff --git a/gfx/gl/bufferedLocation.h b/gfx/gl/bufferedLocation.h
index a5cd23e..30967e3 100644
--- a/gfx/gl/bufferedLocation.h
+++ b/gfx/gl/bufferedLocation.h
@@ -22,7 +22,6 @@ public:
 	void setRotation(Rotation3D, bool update = true);
 	void setLocation(Position3D, Rotation3D);
 
-	[[nodiscard]] glm::mat4 getTransform() const;
 	[[nodiscard]] glm::mat4 getRotationTransform() const;
 
 private:
diff --git a/lib/location.cpp b/lib/location.cpp
index 9a31402..ff7cfa6 100644
--- a/lib/location.cpp
+++ b/lib/location.cpp
@@ -2,12 +2,6 @@
 #include "maths.h"
 #include <glm/gtx/transform.hpp>
 
-glm::mat4
-Location::getTransform() const
-{
-	return glm::translate(pos) * rotate_ypr(rot);
-}
-
 glm::mat4
 Location::getRotationTransform() const
 {
diff --git a/lib/location.h b/lib/location.h
index 55737ae..85834a0 100644
--- a/lib/location.h
+++ b/lib/location.h
@@ -9,7 +9,6 @@ public:
 	explicit Location(Position3D pos = {}, Rotation3D rot = {}) : pos {pos}, rot {rot} { }
 #endif
 
-	[[nodiscard]] glm::mat4 getTransform() const;
 	[[nodiscard]] glm::mat4 getRotationTransform() const;
 
 	Position3D pos;
-- 
cgit v1.2.3


From 0aa665c3648d788755b00c9e431c872d57fddbb8 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 25 Nov 2023 16:28:39 +0000
Subject: Model positions as integers

Introduces test failure in arcs due to rounding, but I don't want to create a complicated
fix as link positions are still floats and hopefully that'll go away... somehow
---
 config/types.h                           | 19 +++++++++++++++----
 game/geoData.cpp                         |  4 ++--
 game/scenary/foliage.h                   |  2 +-
 game/vehicles/railVehicle.cpp            | 22 +++++++++++-----------
 game/vehicles/railVehicleClass.h         |  2 +-
 gfx/followCameraController.cpp           |  4 ++--
 gfx/gl/bufferedLocation.cpp              |  8 ++++----
 gfx/gl/bufferedLocation.h                |  8 ++++----
 gfx/gl/sceneShader.cpp                   |  2 +-
 gfx/gl/shaders/dynamicPoint.vs           |  2 +-
 gfx/gl/shaders/dynamicPointInst.vs       |  2 +-
 gfx/gl/shaders/fixedPoint.vs             |  2 +-
 gfx/gl/shaders/shadowDynamicPoint.vs     |  2 +-
 gfx/gl/shaders/shadowDynamicPointInst.vs |  2 +-
 gfx/gl/shaders/shadowFixedPoint.vs       |  2 +-
 gfx/gl/shadowMapper.cpp                  |  2 +-
 lib/location.h                           |  4 ++--
 test/test-maths.cpp                      | 12 ++++++------
 18 files changed, 56 insertions(+), 45 deletions(-)

(limited to 'game')

diff --git a/config/types.h b/config/types.h
index d99735e..6fc7b61 100644
--- a/config/types.h
+++ b/config/types.h
@@ -3,10 +3,14 @@
 #include "glad/gl.h"
 #include <glm/geometric.hpp>
 
-using Distance = float;
+using Distance = float; // deprecate
+using RelativeDistance = float;
+using GlobalDistance = int32_t;
 using Angle = float;
 
-template<glm::length_t D> using Position = glm::vec<D, Distance>;
+template<glm::length_t D> using Position = glm::vec<D, Distance>; // deprecate
+template<glm::length_t D> using RelativePosition = glm::vec<D, RelativeDistance>;
+template<glm::length_t D> using GlobalPosition = glm::vec<D, GlobalDistance>;
 template<glm::length_t D> using Size = glm::vec<D, Distance>;
 template<glm::length_t D> using Scale = glm::vec<D, float>;
 template<glm::length_t D> using Direction = glm::vec<D, float>;
@@ -14,8 +18,15 @@ template<glm::length_t D> using Normal = Direction<D>;
 template<glm::length_t D> using Rotation = glm::vec<D, Angle>;
 template<glm::length_t Channels> using Colour = glm::vec<Channels, float>;
 
-using Position2D = Position<2>;
-using Position3D = Position<3>;
+using Position2D = Position<2>; // deprecate
+using Position3D = Position<3>; // deprecate
+using BaryPosition = glm::vec<2, float>;
+using RelativePosition2D = RelativePosition<2>;
+using RelativePosition3D = RelativePosition<3>;
+using RelativePosition4D = RelativePosition<4>;
+using GlobalPosition2D = GlobalPosition<2>;
+using GlobalPosition3D = GlobalPosition<3>;
+using GlobalPosition4D = GlobalPosition<4>;
 using Size2D = Size<2>;
 using Size3D = Size<3>;
 using Scale2D = Scale<2>;
diff --git a/game/geoData.cpp b/game/geoData.cpp
index da067f7..ec990ea 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -73,7 +73,7 @@ GeoData::loadFromImages(const std::filesystem::path & fileName, float scale_)
 }
 
 GeoData::Quad
-GeoData::quad(glm::vec2 wcoord) const
+GeoData::quad(Position2D wcoord) const
 {
 	constexpr static const std::array<glm::vec2, 4> corners {{{0, 0}, {0, 1}, {1, 0}, {1, 1}}};
 	return transform_array(transform_array(corners,
@@ -154,7 +154,7 @@ GeoData::intersectRay(const Ray & ray) const
 		try {
 			const auto point = quad(n);
 			for (auto offset : {0U, 1U}) {
-				glm::vec2 bary;
+				BaryPosition bary;
 				float distance;
 				if (glm::intersectRayTriangle(ray.start, ray.direction, point[offset], point[offset + 1],
 							point[offset + 2], bary, distance)) {
diff --git a/game/scenary/foliage.h b/game/scenary/foliage.h
index 5a9d2de..bbb6200 100644
--- a/game/scenary/foliage.h
+++ b/game/scenary/foliage.h
@@ -15,7 +15,7 @@ class Foliage : public Asset, public Renderable, public StdTypeDefs<Foliage> {
 	glVertexArray instanceVAO;
 
 public:
-	using LocationVertex = std::pair<glm::mat4, Position3D>;
+	using LocationVertex = std::pair<glm::mat4, GlobalPosition3D>;
 	mutable InstanceVertices<LocationVertex> instances;
 	void render(const SceneShader &) const override;
 	void shadows(const ShadowMapper &) const override;
diff --git a/game/vehicles/railVehicle.cpp b/game/vehicles/railVehicle.cpp
index bee0dd0..30b615c 100644
--- a/game/vehicles/railVehicle.cpp
+++ b/game/vehicles/railVehicle.cpp
@@ -38,9 +38,9 @@ RailVehicle::move(const Train * t, float & trailBy)
 	const auto overhang {(rvClass->length - rvClass->wheelBase) / 2};
 	const auto & b1Pos = bogies[0] = t->getBogiePosition(t->linkDist, trailBy += overhang);
 	const auto & b2Pos = bogies[1] = t->getBogiePosition(t->linkDist, trailBy += rvClass->wheelBase);
-	const auto diff = glm::normalize(b2Pos.position() - b1Pos.position());
-	location.setLocation((b1Pos.position() + b2Pos.position()) / 2.F, {vector_pitch(diff), vector_yaw(diff), 0});
-	trailBy += 0.6F + overhang;
+	const auto diff = glm::normalize(RelativePosition3D(b2Pos.position() - b1Pos.position()));
+	location.setLocation((b1Pos.position() + b2Pos.position()) / 2, {vector_pitch(diff), vector_yaw(diff), 0});
+	trailBy += 600.F + overhang;
 }
 
 bool
@@ -51,14 +51,14 @@ RailVehicle::intersectRay(const Ray & ray, Position2D * baryPos, float * distanc
 	constexpr const auto Z = 3900.F;
 	const auto moveBy = location.getRotationTransform();
 	const std::array<Position3D, 8> cornerVertices {{
-			location.position() + (moveBy * glm::vec4 {-X, Y, 0, 1}).xyz(), //  LFB
-			location.position() + (moveBy * glm::vec4 {X, Y, 0, 1}).xyz(), //   RFB
-			location.position() + (moveBy * glm::vec4 {-X, Y, Z, 1}).xyz(), //  LFT
-			location.position() + (moveBy * glm::vec4 {X, Y, Z, 1}).xyz(), //   RFT
-			location.position() + (moveBy * glm::vec4 {-X, -Y, 0, 1}).xyz(), // LBB
-			location.position() + (moveBy * glm::vec4 {X, -Y, 0, 1}).xyz(), //  RBB
-			location.position() + (moveBy * glm::vec4 {-X, -Y, Z, 1}).xyz(), // LBT
-			location.position() + (moveBy * glm::vec4 {X, -Y, Z, 1}).xyz(), //  RBT
+			location.position() + GlobalPosition3D(moveBy * glm::vec4 {-X, Y, 0, 1}).xyz(), //  LFB
+			location.position() + GlobalPosition3D(moveBy * glm::vec4 {X, Y, 0, 1}).xyz(), //   RFB
+			location.position() + GlobalPosition3D(moveBy * glm::vec4 {-X, Y, Z, 1}).xyz(), //  LFT
+			location.position() + GlobalPosition3D(moveBy * glm::vec4 {X, Y, Z, 1}).xyz(), //   RFT
+			location.position() + GlobalPosition3D(moveBy * glm::vec4 {-X, -Y, 0, 1}).xyz(), // LBB
+			location.position() + GlobalPosition3D(moveBy * glm::vec4 {X, -Y, 0, 1}).xyz(), //  RBB
+			location.position() + GlobalPosition3D(moveBy * glm::vec4 {-X, -Y, Z, 1}).xyz(), // LBT
+			location.position() + GlobalPosition3D(moveBy * glm::vec4 {X, -Y, Z, 1}).xyz(), //  RBT
 	}};
 	static constexpr const std::array<glm::vec<3, uint8_t>, 10> triangles {{
 			// Front
diff --git a/game/vehicles/railVehicleClass.h b/game/vehicles/railVehicleClass.h
index 16dce01..913feea 100644
--- a/game/vehicles/railVehicleClass.h
+++ b/game/vehicles/railVehicleClass.h
@@ -20,7 +20,7 @@ public:
 
 	struct LocationVertex {
 		glm::mat4 body, front, back;
-		Position3D bodyPos, frontPos, backPos;
+		GlobalPosition3D bodyPos, frontPos, backPos;
 	};
 
 	std::array<Mesh::Ptr, 2> bogies;
diff --git a/gfx/followCameraController.cpp b/gfx/followCameraController.cpp
index 5b08483..aee2187 100644
--- a/gfx/followCameraController.cpp
+++ b/gfx/followCameraController.cpp
@@ -24,11 +24,11 @@ FollowCameraController::updateCamera(Camera * camera) const
 			break;
 
 		case Mode::Ride:
-			camera->setView(pos + (up * 4.8F), !-sincosf(rot.y));
+			camera->setView(pos + GlobalPosition3D(up * 4.8F), !-sincosf(rot.y));
 			break;
 
 		case Mode::ISO:
-			camera->setView(pos + ((up + north + east) * 40.F), glm::normalize(down + south + west),
+			camera->setView(pos + GlobalPosition3D((up + north + east) * 40.F), glm::normalize(down + south + west),
 					glm::normalize(up - north - east));
 			break;
 	}
diff --git a/gfx/gl/bufferedLocation.cpp b/gfx/gl/bufferedLocation.cpp
index 2a2e723..d6a63b9 100644
--- a/gfx/gl/bufferedLocation.cpp
+++ b/gfx/gl/bufferedLocation.cpp
@@ -2,7 +2,7 @@
 #include "location.h"
 #include <glm/gtx/transform.hpp>
 
-BufferedLocation::BufferedLocation(Position3D p, Rotation3D r) : BufferedLocation {Location {p, r}} { }
+BufferedLocation::BufferedLocation(GlobalPosition3D p, Rotation3D r) : BufferedLocation {Location {p, r}} { }
 
 BufferedLocation::BufferedLocation(const Location & l) : loc {l} { }
 
@@ -19,7 +19,7 @@ BufferedLocation::operator=(const Location & l)
 	return *this;
 }
 
-Position3D
+GlobalPosition3D
 BufferedLocation::position() const
 {
 	return loc.pos;
@@ -32,7 +32,7 @@ BufferedLocation::rotation() const
 }
 
 void
-BufferedLocation::setPosition(Position3D p, bool update)
+BufferedLocation::setPosition(GlobalPosition3D p, bool update)
 {
 	loc.pos = p;
 	if (update) {
@@ -50,7 +50,7 @@ BufferedLocation::setRotation(Position3D r, bool update)
 }
 
 void
-BufferedLocation::setLocation(Position3D p, Rotation3D r)
+BufferedLocation::setLocation(GlobalPosition3D p, Rotation3D r)
 {
 	loc.pos = p;
 	loc.rot = r;
diff --git a/gfx/gl/bufferedLocation.h b/gfx/gl/bufferedLocation.h
index 30967e3..87b957f 100644
--- a/gfx/gl/bufferedLocation.h
+++ b/gfx/gl/bufferedLocation.h
@@ -8,7 +8,7 @@
 
 class BufferedLocation {
 public:
-	BufferedLocation(Position3D = {}, Rotation3D = {});
+	BufferedLocation(GlobalPosition3D = {}, Rotation3D = {});
 	BufferedLocation(const Location &);
 	virtual ~BufferedLocation() = default;
 
@@ -16,11 +16,11 @@ public:
 
 	operator const Location &() const;
 
-	[[nodiscard]] Position3D position() const;
+	[[nodiscard]] GlobalPosition3D position() const;
 	[[nodiscard]] Rotation3D rotation() const;
-	void setPosition(Position3D, bool update = true);
+	void setPosition(GlobalPosition3D, bool update = true);
 	void setRotation(Rotation3D, bool update = true);
-	void setLocation(Position3D, Rotation3D);
+	void setLocation(GlobalPosition3D, Rotation3D);
 
 	[[nodiscard]] glm::mat4 getRotationTransform() const;
 
diff --git a/gfx/gl/sceneShader.cpp b/gfx/gl/sceneShader.cpp
index de75814..59a9748 100644
--- a/gfx/gl/sceneShader.cpp
+++ b/gfx/gl/sceneShader.cpp
@@ -69,7 +69,7 @@ void
 SceneShader::BasicProgram::setModel(Location const & location) const
 {
 	glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(rotate_ypr(location.rot)));
-	glUniform3fv(modelPosLoc, 1, glm::value_ptr(location.pos));
+	glUniform3iv(modelPosLoc, 1, glm::value_ptr(location.pos));
 }
 
 void
diff --git a/gfx/gl/shaders/dynamicPoint.vs b/gfx/gl/shaders/dynamicPoint.vs
index 9dd6a47..667f247 100644
--- a/gfx/gl/shaders/dynamicPoint.vs
+++ b/gfx/gl/shaders/dynamicPoint.vs
@@ -7,6 +7,6 @@ include(`materialInterface.glsl')
 uniform mat4 viewProjection;
 uniform vec3 viewPoint;
 uniform mat4 model;
-uniform vec3 modelPos;
+uniform ivec3 modelPos;
 
 include(`commonPoint.glsl')
diff --git a/gfx/gl/shaders/dynamicPointInst.vs b/gfx/gl/shaders/dynamicPointInst.vs
index 4ae6813..adf39bd 100644
--- a/gfx/gl/shaders/dynamicPointInst.vs
+++ b/gfx/gl/shaders/dynamicPointInst.vs
@@ -7,6 +7,6 @@ include(`materialInterface.glsl')
 uniform mat4 viewProjection;
 uniform vec3 viewPoint;
 layout(location = 5) in mat4 model;
-layout(location = 9) in vec3 modelPos;
+layout(location = 9) in ivec3 modelPos;
 
 include(`commonPoint.glsl')
diff --git a/gfx/gl/shaders/fixedPoint.vs b/gfx/gl/shaders/fixedPoint.vs
index 0adbb02..6e1ab49 100644
--- a/gfx/gl/shaders/fixedPoint.vs
+++ b/gfx/gl/shaders/fixedPoint.vs
@@ -7,6 +7,6 @@ include(`materialInterface.glsl')
 uniform mat4 viewProjection;
 uniform vec3 viewPoint;
 const mat4 model = mat4(1);
-const vec3 modelPos = vec3(0);
+const vec3 modelPos = ivec3(0);
 
 include(`commonPoint.glsl')
diff --git a/gfx/gl/shaders/shadowDynamicPoint.vs b/gfx/gl/shaders/shadowDynamicPoint.vs
index eb25423..e20d31a 100644
--- a/gfx/gl/shaders/shadowDynamicPoint.vs
+++ b/gfx/gl/shaders/shadowDynamicPoint.vs
@@ -5,6 +5,6 @@ include(`meshIn.glsl')
 uniform mat4 viewProjection;
 uniform vec3 viewPoint;
 uniform mat4 model;
-uniform vec3 modelPos;
+uniform ivec3 modelPos;
 
 include(`commonShadowPoint.glsl')
diff --git a/gfx/gl/shaders/shadowDynamicPointInst.vs b/gfx/gl/shaders/shadowDynamicPointInst.vs
index a0f51c3..ab3e976 100644
--- a/gfx/gl/shaders/shadowDynamicPointInst.vs
+++ b/gfx/gl/shaders/shadowDynamicPointInst.vs
@@ -5,6 +5,6 @@ include(`meshIn.glsl')
 uniform mat4 viewProjection;
 uniform vec3 viewPoint;
 layout(location = 5) in mat4 model;
-layout(location = 9) in vec3 modelPos;
+layout(location = 9) in ivec3 modelPos;
 
 include(`commonShadowPoint.glsl')
diff --git a/gfx/gl/shaders/shadowFixedPoint.vs b/gfx/gl/shaders/shadowFixedPoint.vs
index dfc5c42..a9fb4a3 100644
--- a/gfx/gl/shaders/shadowFixedPoint.vs
+++ b/gfx/gl/shaders/shadowFixedPoint.vs
@@ -5,6 +5,6 @@ include(`meshIn.glsl')
 uniform mat4 viewProjection;
 uniform vec3 viewPoint;
 const mat4 model = mat4(1);
-const vec3 modelPos = vec3(0);
+const ivec3 modelPos = ivec3(0);
 
 include(`commonShadowPoint.glsl')
diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 4a8d7ec..07db6a1 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -202,5 +202,5 @@ void
 ShadowMapper::DynamicPoint::setModel(const Location & location) const
 {
 	glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(rotate_ypr(location.rot)));
-	glUniform3fv(modelPosLoc, 1, glm::value_ptr(location.pos));
+	glUniform3iv(modelPosLoc, 1, glm::value_ptr(location.pos));
 }
diff --git a/lib/location.h b/lib/location.h
index 85834a0..8570fc2 100644
--- a/lib/location.h
+++ b/lib/location.h
@@ -6,11 +6,11 @@
 class Location {
 public:
 #ifndef __cpp_aggregate_paren_init
-	explicit Location(Position3D pos = {}, Rotation3D rot = {}) : pos {pos}, rot {rot} { }
+	explicit Location(GlobalPosition3D pos = {}, Rotation3D rot = {}) : pos {pos}, rot {rot} { }
 #endif
 
 	[[nodiscard]] glm::mat4 getRotationTransform() const;
 
-	Position3D pos;
+	GlobalPosition3D pos;
 	Rotation3D rot;
 };
diff --git a/test/test-maths.cpp b/test/test-maths.cpp
index 2560319..9eae918 100644
--- a/test/test-maths.cpp
+++ b/test/test-maths.cpp
@@ -196,12 +196,12 @@ BOOST_DATA_TEST_CASE(straight1,
 	const TestLinkStraight l(v);
 	{
 		const auto p = l.positionAt(0, 0);
-		BOOST_CHECK_EQUAL(p.pos, origin);
+		BOOST_CHECK_EQUAL(p.pos, GlobalPosition3D {origin});
 		BOOST_CHECK_EQUAL(p.rot, glm::vec3(0, angFor, 0));
 	}
 	{
 		const auto p = l.positionAt(0, 1);
-		BOOST_CHECK_EQUAL(p.pos, v);
+		BOOST_CHECK_EQUAL(p.pos, GlobalPosition3D {v});
 		BOOST_CHECK_EQUAL(p.rot, glm::vec3(0, angBack, 0));
 	}
 }
@@ -231,12 +231,12 @@ BOOST_DATA_TEST_CASE(curve1,
 		BOOST_CHECK_EQUAL(l.radius, 1.F);
 		{
 			const auto p = l.positionAt(0, 0);
-			BOOST_CHECK_CLOSE_VEC(p.pos, origin);
+			BOOST_CHECK_CLOSE_VEC(RelativePosition3D {p.pos}, origin);
 			BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angFor, 0));
 		}
 		{
 			const auto p = l.positionAt(0, 1);
-			BOOST_CHECK_CLOSE_VEC(p.pos, e1);
+			BOOST_CHECK_CLOSE_VEC(RelativePosition3D {p.pos}, e1);
 			BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angBack, 0));
 		}
 	}
@@ -247,13 +247,13 @@ BOOST_DATA_TEST_CASE(curve1,
 		{
 			const auto p = l.positionAt(0, 0);
 			const auto angForReversed = normalize(vector_yaw(origin - e1) * 2 - angFor);
-			BOOST_CHECK_CLOSE_VEC(p.pos, e1);
+			BOOST_CHECK_CLOSE_VEC(RelativePosition3D {p.pos}, e1);
 			BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angForReversed, 0));
 		}
 		{
 			const auto p = l.positionAt(0, 1);
 			const auto angBackReversed = normalize(vector_yaw(e1 - origin) * 2 - angBack);
-			BOOST_CHECK_CLOSE_VEC(p.pos, origin);
+			BOOST_CHECK_CLOSE_VEC(RelativePosition3D {p.pos}, origin);
 			BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angBackReversed, 0));
 		}
 	}
-- 
cgit v1.2.3


From 3abe940a22d99939b666bd806214c8b986cb3ed9 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 26 Nov 2023 14:20:28 +0000
Subject: Calculate vertex normals only

Doesn't require half edge normals or face normals, which uses Newell's
method, which results in integer overflow... Not to mention we don't
need all the other normals.
---
 game/geoData.cpp      | 16 ++++++++++++----
 game/geoData.h        |  6 ++++--
 test/test-geoData.cpp |  5 -----
 3 files changed, 16 insertions(+), 11 deletions(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index 7710efe..70133a9 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -57,8 +57,7 @@ GeoData::loadFromAsciiGrid(const std::filesystem::path & input)
 			});
 		}
 	}
-	mesh.update_face_normals();
-	mesh.update_vertex_normals();
+	mesh.update_vertex_normals_only();
 
 	return mesh;
 };
@@ -77,8 +76,7 @@ GeoData::createFlat(GlobalPosition2D lower, GlobalPosition2D upper, GlobalDistan
 	mesh.add_face(ll, uu, lu);
 	mesh.add_face(ll, ul, uu);
 
-	mesh.update_face_normals();
-	mesh.update_vertex_normals();
+	mesh.update_vertex_normals_only();
 
 	return mesh;
 }
@@ -317,3 +315,13 @@ GeoData::findBoundaryStart() const
 		return is_boundary(heh);
 	});
 }
+
+void
+GeoData::update_vertex_normals_only()
+{
+	for (auto vh : all_vertices()) {
+		Normal3D n;
+		calc_vertex_normal_correct(vh, n);
+		this->set_normal(vh, glm::normalize(n));
+	}
+}
diff --git a/game/geoData.h b/game/geoData.h
index 3141dbe..d4d0fb3 100644
--- a/game/geoData.h
+++ b/game/geoData.h
@@ -10,10 +10,10 @@
 #include <thirdparty/openmesh/glmcompat.h>
 
 struct GeoDataTraits : public OpenMesh::DefaultTraits {
-	FaceAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
+	FaceAttributes(OpenMesh::Attributes::Status);
 	EdgeAttributes(OpenMesh::Attributes::Status);
 	VertexAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
-	HalfedgeAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
+	HalfedgeAttributes(OpenMesh::Attributes::Status);
 	using Point = GlobalPosition3D;
 	using Normal = Normal3D;
 };
@@ -105,6 +105,8 @@ protected:
 	[[nodiscard]] bool triangleContainsPoint(const GlobalPosition2D, FaceHandle) const;
 	[[nodiscard]] HalfedgeHandle findBoundaryStart() const;
 
+	void update_vertex_normals_only();
+
 private:
 	GlobalPosition3D lowerExtent {}, upperExtent {};
 };
diff --git a/test/test-geoData.cpp b/test/test-geoData.cpp
index 4e85f73..cb0466e 100644
--- a/test/test-geoData.cpp
+++ b/test/test-geoData.cpp
@@ -26,11 +26,6 @@ BOOST_AUTO_TEST_CASE(loadSuccess)
 
 BOOST_AUTO_TEST_CASE(normalsAllPointUp)
 {
-	BOOST_CHECK_EQUAL(std::count_if(faces_begin(), faces_end(),
-							  [this](auto && vh) {
-								  return normal(vh).z > 0;
-							  }),
-			n_faces());
 	BOOST_CHECK_EQUAL(std::count_if(vertices_begin(), vertices_end(),
 							  [this](auto && vh) {
 								  return normal(vh).z > 0;
-- 
cgit v1.2.3


From 0c97f72d6f3feab22a37f8d33e2d98080d52dab7 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 26 Nov 2023 18:50:56 +0000
Subject: Fix terrain texture tiling

---
 game/terrain.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'game')

diff --git a/game/terrain.cpp b/game/terrain.cpp
index 5bb8abd..3778f3d 100644
--- a/game/terrain.cpp
+++ b/game/terrain.cpp
@@ -35,8 +35,8 @@ Terrain::generateMeshes()
 	std::transform(geoData->vertices_begin(), geoData->vertices_end(), std::back_inserter(vertices),
 			[this, &vertexIndex](const GeoData::VertexHandle v) {
 				vertexIndex.emplace(v, vertexIndex.size());
-				const glm::vec3 p = geoData->point(v);
-				return Vertex {p, p / 10.F, geoData->normal(v)};
+				const auto p = geoData->point(v);
+				return Vertex {p, p / 10000, geoData->normal(v)};
 			});
 	std::for_each(
 			geoData->faces_begin(), geoData->faces_end(), [this, &vertexIndex, &indices](const GeoData::FaceHandle f) {
-- 
cgit v1.2.3


From 0f56b13766fc6d8b45dabc4febf378756620ab32 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 2 Dec 2023 12:26:36 +0000
Subject: Replace positionAt with pure integer version

---
 game/geoData.cpp      | 15 +++++++++++----
 test/test-geoData.cpp |  2 +-
 2 files changed, 12 insertions(+), 5 deletions(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index 70133a9..d092d00 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -155,6 +155,16 @@ namespace {
 
 	static_assert(linesCrossLtR({1, 1}, {2, 2}, {1, 2}, {2, 1}));
 	static_assert(!linesCrossLtR({2, 2}, {1, 1}, {1, 2}, {2, 1}));
+
+	constexpr GlobalPosition3D
+	positionOnTriangle(const GlobalPosition2D point, const GeoData::Triangle<3> & t)
+	{
+		const glm::vec<3, int64_t> a = t[1] - t[0], b = t[2] - t[0];
+		const auto n = crossInt(a, b);
+		return {point, ((n.x * t[0].x) + (n.y * t[0].y) + (n.z * t[0].z) - (n.x * point.x) - (n.y * point.y)) / n.z};
+	}
+
+	static_assert(positionOnTriangle({7, -2}, {{1, 2, 3}, {1, 0, 1}, {-2, 1, 0}}) == GlobalPosition3D {7, -2, 3});
 }
 
 OpenMesh::FaceHandle
@@ -179,10 +189,7 @@ GeoData::findPoint(GlobalPosition2D p, OpenMesh::FaceHandle f) const
 GlobalPosition3D
 GeoData::positionAt(const PointFace & p) const
 {
-	RelativePosition3D out {};
-	const auto t = triangle<3>(p.face(this));
-	glm::intersectLineTriangle<RelativePosition3D>({p.point, 0}, up, t[0], t[1], t[2], out);
-	return {p.point, out[0]};
+	return positionOnTriangle(p.point, triangle<3>(p.face(this)));
 }
 
 [[nodiscard]] std::optional<GlobalPosition3D>
diff --git a/test/test-geoData.cpp b/test/test-geoData.cpp
index cb0466e..164a6a5 100644
--- a/test/test-geoData.cpp
+++ b/test/test-geoData.cpp
@@ -92,7 +92,7 @@ BOOST_DATA_TEST_CASE(findPositionAt,
 				{{310050000, 490050000}, 33000},
 				{{310000000, 490050000}, 32700},
 				{{310050000, 490000000}, 33200},
-				{{310750000, 490150000}, 58399},
+				{{310750000, 490150000}, 58400},
 				// midpoints
 				{{310025000, 490025000}, 32900},
 				{{310025000, 490050000}, 32850},
-- 
cgit v1.2.3


From 0ec5b3f7ee049a45fa6a87101813ea9717eecbbb Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 2 Dec 2023 16:25:27 +0000
Subject: Extend ray for intersect walk to cover the extents of the map

---
 game/geoData.cpp | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index d092d00..6c6f1df 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -202,17 +202,19 @@ GeoData::intersectRay(const Ray & ray) const
 GeoData::intersectRay(const Ray & ray, FaceHandle face) const
 {
 	std::optional<GlobalPosition3D> out;
-	walkUntil(PointFace {ray.start, face}, ray.start + (ray.direction * 10000.F), [&out, &ray, this](FaceHandle face) {
-		BaryPosition bari {};
-		float dist {};
-		const auto t = triangle<3>(face);
-		if (glm::intersectRayTriangle<RelativePosition3D::value_type, glm::defaultp>(
-					ray.start, ray.direction, t[0], t[1], t[2], bari, dist)) {
-			out = t * bari;
-			return true;
-		}
-		return false;
-	});
+	walkUntil(PointFace {ray.start, face},
+			ray.start.xy() + (ray.direction.xy() * RelativePosition2D(upperExtent.xy() - lowerExtent.xy())),
+			[&out, &ray, this](FaceHandle face) {
+				BaryPosition bari {};
+				float dist {};
+				const auto t = triangle<3>(face);
+				if (glm::intersectRayTriangle<RelativePosition3D::value_type, glm::defaultp>(
+							ray.start, ray.direction, t[0], t[1], t[2], bari, dist)) {
+					out = t * bari;
+					return true;
+				}
+				return false;
+			});
 	return out;
 }
 
-- 
cgit v1.2.3


From 826a380710261961eb339d12d44f1c45fc384131 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 2 Dec 2023 16:36:11 +0000
Subject: Handle the case where the ray never enters the map

---
 game/geoData.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index 6c6f1df..e2b7f66 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -232,7 +232,11 @@ GeoData::walkUntil(const PointFace & from, const GlobalPosition2D to, const std:
 {
 	auto f = from.face(this);
 	if (!f.is_valid()) {
-		f = opposite_face_handle(findEntry(from.point, to));
+		const auto entryEdge = findEntry(from.point, to);
+		if (!entryEdge.is_valid()) {
+			return;
+		}
+		f = opposite_face_handle(entryEdge);
 	}
 	FaceHandle previousFace;
 	while (f.is_valid() && !op(f)) {
-- 
cgit v1.2.3


From 9fc82f2dd5aaa6f858ba22c92946e8cadfd7d79b Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 3 Dec 2023 13:50:24 +0000
Subject: Render correct VAO for rail vehicle shadows

---
 game/vehicles/railVehicleClass.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'game')

diff --git a/game/vehicles/railVehicleClass.cpp b/game/vehicles/railVehicleClass.cpp
index 7a6a9fe..3ca42db 100644
--- a/game/vehicles/railVehicleClass.cpp
+++ b/game/vehicles/railVehicleClass.cpp
@@ -66,7 +66,7 @@ RailVehicleClass::shadows(const ShadowMapper & mapper) const
 	if (const auto count = static_cast<GLsizei>(instances.size())) {
 		mapper.dynamicPointInst.use();
 		bodyMesh->DrawInstanced(instanceVAO, count);
-		bogies.front()->DrawInstanced(instanceVAO, count);
-		bogies.back()->DrawInstanced(instanceVAO, count);
+		bogies.front()->DrawInstanced(instancesBogiesVAO.front(), count);
+		bogies.back()->DrawInstanced(instancesBogiesVAO.back(), count);
 	}
 }
-- 
cgit v1.2.3


From f3f926c97efe365afecd54d06d830961376bae30 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 17 Dec 2023 18:56:23 +0000
Subject: Use new calc types in geoData

---
 game/geoData.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'game')

diff --git a/game/geoData.cpp b/game/geoData.cpp
index e2b7f66..97f4a26 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -120,7 +120,8 @@ namespace {
 	[[nodiscard]] constexpr inline auto
 	pointLineOp(const GlobalPosition2D p, const GlobalPosition2D e1, const GlobalPosition2D e2)
 	{
-		return Op {}(int64_t(e2.x - e1.x) * int64_t(p.y - e1.y), int64_t(e2.y - e1.y) * int64_t(p.x - e1.x));
+		return Op {}(CalcDistance(e2.x - e1.x) * CalcDistance(p.y - e1.y),
+				CalcDistance(e2.y - e1.y) * CalcDistance(p.x - e1.x));
 	}
 
 	constexpr auto pointLeftOfLine = pointLineOp<std::greater>;
@@ -159,7 +160,7 @@ namespace {
 	constexpr GlobalPosition3D
 	positionOnTriangle(const GlobalPosition2D point, const GeoData::Triangle<3> & t)
 	{
-		const glm::vec<3, int64_t> a = t[1] - t[0], b = t[2] - t[0];
+		const CalcPosition3D a = t[1] - t[0], b = t[2] - t[0];
 		const auto n = crossInt(a, b);
 		return {point, ((n.x * t[0].x) + (n.y * t[0].y) + (n.z * t[0].z) - (n.x * point.x) - (n.y * point.y)) / n.z};
 	}
-- 
cgit v1.2.3


From 0841ead91c49a212134f19f7c0b411984b0fda29 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Fri, 29 Dec 2023 13:20:55 +0000
Subject: Remove weird operator! on vec2/3

---
 game/network/link.cpp          |  2 +-
 game/network/network.cpp       |  4 ++--
 game/network/rail.cpp          |  4 ++--
 gfx/followCameraController.cpp |  2 +-
 lib/maths.cpp                  |  2 +-
 lib/maths.h                    | 12 ------------
 ui/manualCameraController.cpp  |  2 +-
 7 files changed, 8 insertions(+), 20 deletions(-)

(limited to 'game')

diff --git a/game/network/link.cpp b/game/network/link.cpp
index 498afe4..d8479dd 100644
--- a/game/network/link.cpp
+++ b/game/network/link.cpp
@@ -46,7 +46,7 @@ LinkCurve::positionAt(float dist, unsigned char start) const
 	const auto es {std::make_pair(ends[start].node.get(), ends[1 - start].node.get())};
 	const auto as {std::make_pair(arc[start], arc[1 - start])};
 	const auto ang {as.first + ((as.second - as.first) * frac)};
-	const auto relPos {!sincosf(ang) * radius};
+	const auto relPos {sincosf(ang) ^ 0.F * radius};
 	const auto relClimb {vehiclePositionOffset()
 			+ Position3D {0, 0, es.first->pos.z - centreBase.z + ((es.second->pos.z - es.first->pos.z) * frac)}};
 	const auto pitch {vector_pitch({0, 0, (es.second->pos.z - es.first->pos.z) / length})};
diff --git a/game/network/network.cpp b/game/network/network.cpp
index d18345c..5de2f5d 100644
--- a/game/network/network.cpp
+++ b/game/network/network.cpp
@@ -100,7 +100,7 @@ Network::genCurveDef(const Position3D & start, const Position3D & end, float sta
 	const auto diff {end - start};
 	const auto vy {vector_yaw(diff)};
 	const auto dir = pi + startDir;
-	const auto flatStart {!start}, flatEnd {!end};
+	const auto flatStart {start.xy()}, flatEnd {end.xy()};
 	const auto n2ed {(vy * 2) - dir - pi};
 	const auto centre {find_arc_centre(flatStart, dir, flatEnd, n2ed)};
 
@@ -115,7 +115,7 @@ Network::genCurveDef(const Position3D & start, const Position3D & end, float sta
 {
 	startDir += pi;
 	endDir += pi;
-	const Position2D flatStart {!start}, flatEnd {!end};
+	const Position2D flatStart {start.xy()}, flatEnd {end.xy()};
 	auto midheight = [&](auto mid) {
 		const auto sm = glm::distance(flatStart, mid), em = glm::distance(flatEnd, mid);
 		return start.z + ((end.z - start.z) * (sm / (sm + em)));
diff --git a/game/network/rail.cpp b/game/network/rail.cpp
index ff101d4..545a728 100644
--- a/game/network/rail.cpp
+++ b/game/network/rail.cpp
@@ -45,7 +45,7 @@ RailLinks::addLinksBetween(Position3D start, Position3D end)
 	if (dir == vector_yaw(end - start)) {
 		return addLink<RailLinkStraight>(start, end);
 	}
-	const Position2D flatStart {!start}, flatEnd {!end};
+	const Position2D flatStart {start.xy()}, flatEnd {end.xy()};
 	if (node2ins.second == NodeIs::InNetwork) {
 		auto midheight = [&](auto mid) {
 			const auto sm = glm::distance(flatStart, mid), em = glm::distance(flatEnd, mid);
@@ -142,7 +142,7 @@ RailLinkStraight::RailLinkStraight(Node::Ptr a, Node::Ptr b, const Position3D &
 }
 
 RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, Position2D c) :
-	RailLinkCurve(a, b, c ^ a->pos.z, {!c, a->pos, b->pos})
+	RailLinkCurve(a, b, c ^ a->pos.z, {c ^ 0.F, a->pos, b->pos})
 {
 }
 
diff --git a/gfx/followCameraController.cpp b/gfx/followCameraController.cpp
index aee2187..9b23173 100644
--- a/gfx/followCameraController.cpp
+++ b/gfx/followCameraController.cpp
@@ -24,7 +24,7 @@ FollowCameraController::updateCamera(Camera * camera) const
 			break;
 
 		case Mode::Ride:
-			camera->setView(pos + GlobalPosition3D(up * 4.8F), !-sincosf(rot.y));
+			camera->setView(pos + GlobalPosition3D(up * 4.8F), -sincosf(rot.y) ^ 0.F);
 			break;
 
 		case Mode::ISO:
diff --git a/lib/maths.cpp b/lib/maths.cpp
index 5430ef6..0c25820 100644
--- a/lib/maths.cpp
+++ b/lib/maths.cpp
@@ -9,7 +9,7 @@ glm::mat4
 flat_orientation(const Direction3D & diff)
 {
 	static const auto oneeighty {glm::rotate(pi, up)};
-	const auto flatdiff {glm::normalize(!!diff)};
+	const auto flatdiff {glm::normalize(diff.xy() ^ 0.F)};
 	auto e {glm::orientation(flatdiff, north)};
 	// Handle if diff is exactly opposite to north
 	return (std::isnan(e[0][0])) ? oneeighty : e;
diff --git a/lib/maths.h b/lib/maths.h
index cf369a7..dd83c4b 100644
--- a/lib/maths.h
+++ b/lib/maths.h
@@ -99,12 +99,6 @@ perspective_divide(glm::vec<4, T, Q> v)
 	return v / v.w;
 }
 
-constexpr inline Position2D
-operator!(const Position3D & v)
-{
-	return {v.x, v.y};
-}
-
 constexpr inline Position3D
 operator^(const Position2D & v, float z)
 {
@@ -117,12 +111,6 @@ operator^(const Position3D & v, float w)
 	return {v.x, v.y, v.z, w};
 }
 
-constexpr inline Position3D
-operator!(const Position2D & v)
-{
-	return v ^ 0.F;
-}
-
 template<glm::length_t L1, glm::length_t L2, typename T, glm::qualifier Q>
 inline constexpr glm::vec<L1 + L2, T, Q>
 operator||(const glm::vec<L1, T, Q> v1, const glm::vec<L2, T, Q> v2)
diff --git a/ui/manualCameraController.cpp b/ui/manualCameraController.cpp
index f6993a8..1f6b510 100644
--- a/ui/manualCameraController.cpp
+++ b/ui/manualCameraController.cpp
@@ -79,5 +79,5 @@ void
 ManualCameraController::updateCamera(Camera * camera) const
 {
 	const auto forward = glm::normalize(sincosf(direction) ^ -sin(pitch));
-	camera->setView(!focus - forward * 3.F * std::pow(dist, 1.3F), forward);
+	camera->setView((focus ^ 0.F) - forward * 3.F * std::pow(dist, 1.3F), forward);
 }
-- 
cgit v1.2.3


From 048f18e2a0b32044525cef41fa053984433c74b9 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Fri, 29 Dec 2023 14:12:40 +0000
Subject: Remove misleading power operator^ on vec2/3

---
 assetFactory/cylinder.cpp      |  6 +++---
 game/network/link.cpp          |  2 +-
 game/network/network.cpp       |  4 ++--
 game/network/rail.cpp          | 10 +++++-----
 gfx/followCameraController.cpp |  2 +-
 gfx/gl/camera.cpp              |  2 +-
 lib/maths.cpp                  |  2 +-
 lib/maths.h                    | 24 +++++++-----------------
 ui/manualCameraController.cpp  |  4 ++--
 9 files changed, 23 insertions(+), 33 deletions(-)

(limited to 'game')

diff --git a/assetFactory/cylinder.cpp b/assetFactory/cylinder.cpp
index ed034fd..58980cf 100644
--- a/assetFactory/cylinder.cpp
+++ b/assetFactory/cylinder.cpp
@@ -19,7 +19,7 @@ Cylinder::createMesh(ModelFactoryMesh & mesh, float lodf) const
 		// Generate bottom face vertices
 		std::vector<OpenMesh::VertexHandle> bottom(P);
 		std::transform(circumference.begin(), circumference.end(), bottom.begin(), [&mesh](const auto & xy) {
-			return mesh.add_vertex(xy ^ 0.F);
+			return mesh.add_vertex(xy || 0.F);
 		});
 		surface.insert(mesh.add_namedFace("bottom", bottom));
 	}
@@ -27,7 +27,7 @@ Cylinder::createMesh(ModelFactoryMesh & mesh, float lodf) const
 		// Generate top face vertices
 		std::vector<OpenMesh::VertexHandle> top(P);
 		std::transform(circumference.rbegin(), circumference.rend(), top.begin(), [&mesh](const auto & xy) {
-			return mesh.add_vertex(xy ^ 1);
+			return mesh.add_vertex(xy || 1.F);
 		});
 		surface.insert(mesh.add_namedFace("top", top));
 	}
@@ -35,7 +35,7 @@ Cylinder::createMesh(ModelFactoryMesh & mesh, float lodf) const
 		// Generate edge vertices
 		std::vector<std::pair<OpenMesh::VertexHandle, OpenMesh::VertexHandle>> edge(P + 1);
 		std::transform(circumference.begin(), circumference.end(), edge.begin(), [&mesh](const auto & xy) {
-			return std::make_pair(mesh.add_vertex(xy ^ 0), mesh.add_vertex(xy ^ 1));
+			return std::make_pair(mesh.add_vertex(xy || 0.F), mesh.add_vertex(xy || 1.F));
 		});
 		// Wrap around
 		edge.back() = edge.front();
diff --git a/game/network/link.cpp b/game/network/link.cpp
index d8479dd..703a1ca 100644
--- a/game/network/link.cpp
+++ b/game/network/link.cpp
@@ -46,7 +46,7 @@ LinkCurve::positionAt(float dist, unsigned char start) const
 	const auto es {std::make_pair(ends[start].node.get(), ends[1 - start].node.get())};
 	const auto as {std::make_pair(arc[start], arc[1 - start])};
 	const auto ang {as.first + ((as.second - as.first) * frac)};
-	const auto relPos {sincosf(ang) ^ 0.F * radius};
+	const auto relPos {(sincosf(ang) || 0.F) * radius};
 	const auto relClimb {vehiclePositionOffset()
 			+ Position3D {0, 0, es.first->pos.z - centreBase.z + ((es.second->pos.z - es.first->pos.z) * frac)}};
 	const auto pitch {vector_pitch({0, 0, (es.second->pos.z - es.first->pos.z) / length})};
diff --git a/game/network/network.cpp b/game/network/network.cpp
index 5de2f5d..1ff5b26 100644
--- a/game/network/network.cpp
+++ b/game/network/network.cpp
@@ -125,7 +125,7 @@ Network::genCurveDef(const Position3D & start, const Position3D & end, float sta
 		const auto c1 = flatStart + sincosf(startDir + half_pi) * radius;
 		const auto c2 = flatEnd + sincosf(endDir + half_pi) * radius;
 		const auto mid = (c1 + c2) / 2.F;
-		const auto midh = mid ^ midheight(mid);
+		const auto midh = mid || midheight(mid);
 		return {{start, midh, c1}, {end, midh, c2}};
 	}
 	else {
@@ -133,7 +133,7 @@ Network::genCurveDef(const Position3D & start, const Position3D & end, float sta
 		const auto c1 = flatStart + sincosf(startDir - half_pi) * radius;
 		const auto c2 = flatEnd + sincosf(endDir - half_pi) * radius;
 		const auto mid = (c1 + c2) / 2.F;
-		const auto midh = mid ^ midheight(mid);
+		const auto midh = mid || midheight(mid);
 		return {{midh, start, c1}, {midh, end, c2}};
 	}
 }
diff --git a/game/network/rail.cpp b/game/network/rail.cpp
index 545a728..303f1c8 100644
--- a/game/network/rail.cpp
+++ b/game/network/rail.cpp
@@ -57,7 +57,7 @@ RailLinks::addLinksBetween(Position3D start, Position3D end)
 			const auto c1 = flatStart + sincosf(dir + half_pi) * radius;
 			const auto c2 = flatEnd + sincosf(dir2 + half_pi) * radius;
 			const auto mid = (c1 + c2) / 2.F;
-			const auto midh = mid ^ midheight(mid);
+			const auto midh = mid || midheight(mid);
 			addLink<RailLinkCurve>(start, midh, c1);
 			return addLink<RailLinkCurve>(end, midh, c2);
 		}
@@ -66,7 +66,7 @@ RailLinks::addLinksBetween(Position3D start, Position3D end)
 			const auto c1 = flatStart + sincosf(dir - half_pi) * radius;
 			const auto c2 = flatEnd + sincosf(dir2 - half_pi) * radius;
 			const auto mid = (c1 + c2) / 2.F;
-			const auto midh = mid ^ midheight(mid);
+			const auto midh = mid || midheight(mid);
 			addLink<RailLinkCurve>(midh, start, c1);
 			return addLink<RailLinkCurve>(midh, end, c2);
 		}
@@ -133,7 +133,7 @@ RailLinkStraight::RailLinkStraight(Node::Ptr a, Node::Ptr b, const Position3D &
 		for (auto ei : {1U, 0U}) {
 			const auto trans {glm::translate(ends[ei].node->pos) * e};
 			for (const auto & rcs : railCrossSection) {
-				const Position3D m {(trans * (rcs.first ^ 1))};
+				const Position3D m {(trans * (rcs.first || 1.F))};
 				vertices.emplace_back(m, Position2D {rcs.second, len * static_cast<float>(ei)}, up);
 			}
 		}
@@ -142,7 +142,7 @@ RailLinkStraight::RailLinkStraight(Node::Ptr a, Node::Ptr b, const Position3D &
 }
 
 RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, Position2D c) :
-	RailLinkCurve(a, b, c ^ a->pos.z, {c ^ 0.F, a->pos, b->pos})
+	RailLinkCurve(a, b, c || a->pos.z, {c || 0.F, a->pos, b->pos})
 {
 }
 
@@ -166,7 +166,7 @@ RailLinkCurve::RailLinkCurve(const Node::Ptr & a, const Node::Ptr & b, Position3
 			const auto t {
 					trans * glm::rotate(half_pi - swing.x, up) * glm::translate(Position3D {radius, 0.F, swing.y})};
 			for (const auto & rcs : railCrossSection) {
-				const Position3D m {(t * (rcs.first ^ 1))};
+				const Position3D m {(t * (rcs.first || 1.F))};
 				vertices.emplace_back(m, Position2D {rcs.second, swing.z}, up);
 			}
 		}
diff --git a/gfx/followCameraController.cpp b/gfx/followCameraController.cpp
index 9b23173..5114840 100644
--- a/gfx/followCameraController.cpp
+++ b/gfx/followCameraController.cpp
@@ -24,7 +24,7 @@ FollowCameraController::updateCamera(Camera * camera) const
 			break;
 
 		case Mode::Ride:
-			camera->setView(pos + GlobalPosition3D(up * 4.8F), -sincosf(rot.y) ^ 0.F);
+			camera->setView(pos + GlobalPosition3D(up * 4.8F), -sincosf(rot.y) || 0.F);
 			break;
 
 		case Mode::ISO:
diff --git a/gfx/gl/camera.cpp b/gfx/gl/camera.cpp
index 06e409e..9f40998 100644
--- a/gfx/gl/camera.cpp
+++ b/gfx/gl/camera.cpp
@@ -18,7 +18,7 @@ Camera::unProject(const ScreenRelCoord & mouse) const
 {
 	static constexpr const glm::vec4 screen {0, 0, 1, 1};
 	const auto mouseProjection = glm::lookAt(::origin, forward, up);
-	return {position, glm::normalize(glm::unProject(mouse ^ 1, mouseProjection, projection, screen))};
+	return {position, glm::normalize(glm::unProject(mouse || 1.F, mouseProjection, projection, screen))};
 }
 
 void
diff --git a/lib/maths.cpp b/lib/maths.cpp
index 0c25820..17082d4 100644
--- a/lib/maths.cpp
+++ b/lib/maths.cpp
@@ -9,7 +9,7 @@ glm::mat4
 flat_orientation(const Direction3D & diff)
 {
 	static const auto oneeighty {glm::rotate(pi, up)};
-	const auto flatdiff {glm::normalize(diff.xy() ^ 0.F)};
+	const auto flatdiff {glm::normalize(diff.xy() || 0.F)};
 	auto e {glm::orientation(flatdiff, north)};
 	// Handle if diff is exactly opposite to north
 	return (std::isnan(e[0][0])) ? oneeighty : e;
diff --git a/lib/maths.h b/lib/maths.h
index dd83c4b..f7ff148 100644
--- a/lib/maths.h
+++ b/lib/maths.h
@@ -99,18 +99,6 @@ perspective_divide(glm::vec<4, T, Q> v)
 	return v / v.w;
 }
 
-constexpr inline Position3D
-operator^(const Position2D & v, float z)
-{
-	return {v.x, v.y, z};
-}
-
-constexpr inline glm::vec4
-operator^(const Position3D & v, float w)
-{
-	return {v.x, v.y, v.z, w};
-}
-
 template<glm::length_t L1, glm::length_t L2, typename T, glm::qualifier Q>
 inline constexpr glm::vec<L1 + L2, T, Q>
 operator||(const glm::vec<L1, T, Q> v1, const glm::vec<L2, T, Q> v2)
@@ -125,15 +113,17 @@ operator||(const glm::vec<L, T, Q> v1, const T v2)
 	return {v1, v2};
 }
 
-inline Position3D
-operator%(const Position3D & p, const glm::mat4 & mutation)
+template<glm::length_t L, typename T, glm::qualifier Q>
+inline constexpr glm::vec<L, T, Q>
+operator%(const glm::vec<L, T, Q> & p, const glm::mat<L + 1, L + 1, T, Q> & mutation)
 {
-	const auto p2 = mutation * (p ^ 1);
+	const auto p2 = mutation * (p || T(1));
 	return p2 / p2.w;
 }
 
-inline Position3D
-operator%=(Position3D & p, const glm::mat4 & mutation)
+template<glm::length_t L, typename T, glm::qualifier Q>
+inline constexpr glm::vec<L, T, Q>
+operator%=(glm::vec<L, T, Q> & p, const glm::mat<L + 1, L + 1, T, Q> & mutation)
 {
 	return p = p % mutation;
 }
diff --git a/ui/manualCameraController.cpp b/ui/manualCameraController.cpp
index 1f6b510..ef26e81 100644
--- a/ui/manualCameraController.cpp
+++ b/ui/manualCameraController.cpp
@@ -78,6 +78,6 @@ ManualCameraController::render(const UIShader &, const Position &) const
 void
 ManualCameraController::updateCamera(Camera * camera) const
 {
-	const auto forward = glm::normalize(sincosf(direction) ^ -sin(pitch));
-	camera->setView((focus ^ 0.F) - forward * 3.F * std::pow(dist, 1.3F), forward);
+	const auto forward = glm::normalize(sincosf(direction) || -sin(pitch));
+	camera->setView((focus || 0.F) - forward * 3.F * std::pow(dist, 1.3F), forward);
 }
-- 
cgit v1.2.3


From 69e6b7d2d349dcc42d2d415a72181ba729d5a19d Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Mon, 1 Jan 2024 15:53:54 +0000
Subject: Remove more use of legacy types

---
 application/main.cpp          |  9 +++++----
 game/vehicles/railVehicle.cpp |  2 +-
 game/vehicles/railVehicle.h   |  2 +-
 game/vehicles/train.cpp       |  2 +-
 game/vehicles/train.h         |  2 +-
 gfx/gl/bufferedLocation.cpp   |  4 ++--
 gfx/gl/camera.cpp             |  4 ++--
 gfx/gl/shadowMapper.cpp       |  2 +-
 gfx/models/vertex.h           |  9 +++++----
 lib/maths.h                   | 13 ++++++-------
 test/test-maths.cpp           | 20 ++++++++++----------
 11 files changed, 35 insertions(+), 34 deletions(-)

(limited to 'game')

diff --git a/application/main.cpp b/application/main.cpp
index 600bbe3..adaec9b 100644
--- a/application/main.cpp
+++ b/application/main.cpp
@@ -47,10 +47,11 @@ public:
 
 		{
 			auto rl = world.create<RailLinks>();
-			const Position3D j {-1120000, -1100000, 3000}, k {-1100000, -1000000, 15000}, l {-1000000, -800000, 20000},
-					m {-900000, -600000, 30000}, n {-600000, -500000, 32000}, o {-500000, -800000, 30000},
-					p {-600000, -900000, 25000}, q {-1025000, -1175000, 10000}, r {-925000, -1075000, 10000};
-			const Position3D s {-1100000, -500000, 15000}, t {-1100000, -450000, 15000}, u {-1000000, -400000, 15000};
+			const GlobalPosition3D j {-1120000, -1100000, 3000}, k {-1100000, -1000000, 15000},
+					l {-1000000, -800000, 20000}, m {-900000, -600000, 30000}, n {-600000, -500000, 32000},
+					o {-500000, -800000, 30000}, p {-600000, -900000, 25000}, q {-1025000, -1175000, 10000},
+					r {-925000, -1075000, 10000}, s {-1100000, -500000, 15000}, t {-1100000, -450000, 15000},
+					u {-1000000, -400000, 15000};
 			auto l3 = rl->addLinksBetween(j, k);
 			rl->addLinksBetween(k, l);
 			rl->addLinksBetween(l, m);
diff --git a/game/vehicles/railVehicle.cpp b/game/vehicles/railVehicle.cpp
index 30b615c..7e4b1ee 100644
--- a/game/vehicles/railVehicle.cpp
+++ b/game/vehicles/railVehicle.cpp
@@ -44,7 +44,7 @@ RailVehicle::move(const Train * t, float & trailBy)
 }
 
 bool
-RailVehicle::intersectRay(const Ray & ray, Position2D * baryPos, float * distance) const
+RailVehicle::intersectRay(const Ray & ray, BaryPosition * baryPos, float * distance) const
 {
 	constexpr const auto X = 1350.F;
 	const auto Y = this->rvClass->length / 2.F;
diff --git a/game/vehicles/railVehicle.h b/game/vehicles/railVehicle.h
index 20d1ea1..8cbc49d 100644
--- a/game/vehicles/railVehicle.h
+++ b/game/vehicles/railVehicle.h
@@ -17,7 +17,7 @@ public:
 
 	void move(const Train *, float & trailBy);
 
-	[[nodiscard]] bool intersectRay(const Ray &, Position2D *, float *) const override;
+	[[nodiscard]] bool intersectRay(const Ray &, BaryPosition *, float *) const override;
 
 	RailVehicleClassPtr rvClass;
 	using LV = RailVehicleClass::LocationVertex;
diff --git a/game/vehicles/train.cpp b/game/vehicles/train.cpp
index 4aa24dc..13905a3 100644
--- a/game/vehicles/train.cpp
+++ b/game/vehicles/train.cpp
@@ -20,7 +20,7 @@ Train::getBogiePosition(float linkDist, float dist) const
 }
 
 bool
-Train::intersectRay(const Ray & ray, Position2D * baryPos, float * distance) const
+Train::intersectRay(const Ray & ray, BaryPosition * baryPos, float * distance) const
 {
 	return applyOne(&RailVehicle::intersectRay, ray, baryPos, distance) != end();
 }
diff --git a/game/vehicles/train.h b/game/vehicles/train.h
index 7f0bb99..c77cd23 100644
--- a/game/vehicles/train.h
+++ b/game/vehicles/train.h
@@ -27,7 +27,7 @@ public:
 		return objects.front()->location;
 	}
 
-	[[nodiscard]] bool intersectRay(const Ray &, Position2D *, float *) const override;
+	[[nodiscard]] bool intersectRay(const Ray &, BaryPosition *, float *) const override;
 
 	void tick(TickDuration elapsed) override;
 	void doActivity(Go *, TickDuration) override;
diff --git a/gfx/gl/bufferedLocation.cpp b/gfx/gl/bufferedLocation.cpp
index d6a63b9..f1bedfe 100644
--- a/gfx/gl/bufferedLocation.cpp
+++ b/gfx/gl/bufferedLocation.cpp
@@ -25,7 +25,7 @@ BufferedLocation::position() const
 	return loc.pos;
 }
 
-Position3D
+Rotation3D
 BufferedLocation::rotation() const
 {
 	return loc.rot;
@@ -41,7 +41,7 @@ BufferedLocation::setPosition(GlobalPosition3D p, bool update)
 }
 
 void
-BufferedLocation::setRotation(Position3D r, bool update)
+BufferedLocation::setRotation(Rotation3D r, bool update)
 {
 	loc.rot = r;
 	if (update) {
diff --git a/gfx/gl/camera.cpp b/gfx/gl/camera.cpp
index 9f40998..d362b94 100644
--- a/gfx/gl/camera.cpp
+++ b/gfx/gl/camera.cpp
@@ -17,14 +17,14 @@ Ray
 Camera::unProject(const ScreenRelCoord & mouse) const
 {
 	static constexpr const glm::vec4 screen {0, 0, 1, 1};
-	const auto mouseProjection = glm::lookAt(::origin, forward, up);
+	const auto mouseProjection = glm::lookAt({}, forward, up);
 	return {position, glm::normalize(glm::unProject(mouse || 1.F, mouseProjection, projection, screen))};
 }
 
 void
 Camera::updateView()
 {
-	viewProjection = projection * glm::lookAt(origin, forward, up);
+	viewProjection = projection * glm::lookAt({}, forward, up);
 	inverseViewProjection = glm::inverse(viewProjection);
 }
 
diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 6c8400e..1498bb0 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -130,7 +130,7 @@ ShadowMapper::update(const SceneProvider & scene, const Direction3D & dir, const
 	glClear(GL_DEPTH_BUFFER_BIT);
 	glCullFace(GL_FRONT);
 
-	const auto lightViewDir = glm::lookAt(origin, dir, up);
+	const auto lightViewDir = glm::lookAt({}, dir, up);
 	const auto lightViewPoint = camera.getPosition();
 	const auto bandViewExtents = getBandViewExtents(camera, lightViewDir);
 
diff --git a/gfx/models/vertex.h b/gfx/models/vertex.h
index 5635fa1..3c6215f 100644
--- a/gfx/models/vertex.h
+++ b/gfx/models/vertex.h
@@ -6,16 +6,17 @@
 class Vertex {
 public:
 #ifndef __cpp_aggregate_paren_init
-	constexpr Vertex(Position3D pos, TextureRelCoord texCoord, Normal3D normal, RGBA colour = {}, GLuint material = 0) :
-		pos {std::move(pos)}, texCoord {std::move(texCoord)}, normal {std::move(normal)}, colour {std::move(colour)},
-		material {material}
+	constexpr Vertex(
+			RelativePosition3D pos, TextureRelCoord texCoord, Normal3D normal, RGBA colour = {}, GLuint material = 0) :
+		pos {std::move(pos)},
+		texCoord {std::move(texCoord)}, normal {std::move(normal)}, colour {std::move(colour)}, material {material}
 	{
 	}
 #endif
 
 	bool operator==(const Vertex &) const = default;
 
-	Position3D pos {};
+	RelativePosition3D pos {};
 	TextureRelCoord texCoord {};
 	Normal3D normal {};
 	RGBA colour {};
diff --git a/lib/maths.h b/lib/maths.h
index ba8c0e6..c1bf61a 100644
--- a/lib/maths.h
+++ b/lib/maths.h
@@ -21,13 +21,12 @@ struct Arc : public std::pair<float, float> {
 	}
 };
 
-constexpr const Position3D origin {0, 0, 0};
-constexpr const Position3D up {0, 0, 1};
-constexpr const Position3D down {0, 0, -1};
-constexpr const Position3D north {0, 1, 0};
-constexpr const Position3D south {0, -1, 0};
-constexpr const Position3D east {1, 0, 0};
-constexpr const Position3D west {-1, 0, 0};
+constexpr const RelativePosition3D up {0, 0, 1};
+constexpr const RelativePosition3D down {0, 0, -1};
+constexpr const RelativePosition3D north {0, 1, 0};
+constexpr const RelativePosition3D south {0, -1, 0};
+constexpr const RelativePosition3D east {1, 0, 0};
+constexpr const RelativePosition3D west {-1, 0, 0};
 constexpr auto half_pi {glm::half_pi<float>()};
 constexpr auto quarter_pi {half_pi / 2};
 constexpr auto pi {glm::pi<float>()};
diff --git a/test/test-maths.cpp b/test/test-maths.cpp
index ede884d..b363c17 100644
--- a/test/test-maths.cpp
+++ b/test/test-maths.cpp
@@ -177,7 +177,7 @@ BOOST_AUTO_TEST_CASE(test_find_arcs_radius)
 
 struct TestLinkStraight : public LinkStraight {
 	explicit TestLinkStraight(glm::vec3 v) :
-		Link {{std::make_shared<Node>(origin), vector_yaw(v)}, {std::make_shared<Node>(v), vector_yaw(-v)},
+		Link {{std::make_shared<Node>(Position3D {}), vector_yaw(v)}, {std::make_shared<Node>(v), vector_yaw(-v)},
 				glm::length(v)}
 	{
 	}
@@ -197,7 +197,7 @@ BOOST_DATA_TEST_CASE(straight1,
 	const TestLinkStraight l(v);
 	{
 		const auto p = l.positionAt(0, 0);
-		BOOST_CHECK_EQUAL(p.pos, GlobalPosition3D {origin});
+		BOOST_CHECK_EQUAL(p.pos, GlobalPosition3D {});
 		BOOST_CHECK_EQUAL(p.rot, glm::vec3(0, angFor, 0));
 	}
 	{
@@ -228,11 +228,11 @@ BOOST_DATA_TEST_CASE(curve1,
 		e1, ctr, angFor, angBack)
 {
 	{ // One-way...
-		const TestLinkCurve l(origin, e1, ctr);
+		const TestLinkCurve l({}, e1, ctr);
 		BOOST_CHECK_EQUAL(l.radius, 1.F);
 		{
 			const auto p = l.positionAt(0, 0);
-			BOOST_CHECK_CLOSE_VEC(RelativePosition3D {p.pos}, origin);
+			BOOST_CHECK_CLOSE_VEC(RelativePosition3D {p.pos}, RelativePosition3D {});
 			BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angFor, 0));
 		}
 		{
@@ -243,18 +243,18 @@ BOOST_DATA_TEST_CASE(curve1,
 	}
 
 	{ // The other way...
-		const TestLinkCurve l(e1, origin, ctr);
+		const TestLinkCurve l(e1, {}, ctr);
 		BOOST_CHECK_EQUAL(l.radius, 1.F);
 		{
 			const auto p = l.positionAt(0, 0);
-			const auto angForReversed = normalize(vector_yaw(origin - e1) * 2 - angFor);
+			const auto angForReversed = normalize(vector_yaw(-e1) * 2 - angFor);
 			BOOST_CHECK_CLOSE_VECI(RelativePosition3D {p.pos}, e1);
 			BOOST_CHECK_CLOSE_VECI(p.rot, glm::vec3(0, angForReversed, 0));
 		}
 		{
 			const auto p = l.positionAt(0, 1);
-			const auto angBackReversed = normalize(vector_yaw(e1 - origin) * 2 - angBack);
-			BOOST_CHECK_CLOSE_VEC(RelativePosition3D {p.pos}, origin);
+			const auto angBackReversed = normalize(vector_yaw(e1) * 2 - angBack);
+			BOOST_CHECK_CLOSE_VEC(RelativePosition3D {p.pos}, Position3D {});
 			BOOST_CHECK_CLOSE_VEC(p.rot, glm::vec3(0, angBackReversed, 0));
 		}
 	}
@@ -262,10 +262,10 @@ BOOST_DATA_TEST_CASE(curve1,
 
 BOOST_AUTO_TEST_CASE(camera_clicks)
 {
-	Camera camera {::origin, ::half_pi, 1.25F, 1000, 10000000};
+	Camera camera {{}, ::half_pi, 1.25F, 1000, 10000000};
 	constexpr float centre {0.5F}, right {0.9F}, left {0.1F}, top {1.F}, bottom {0.F};
 	camera.setForward(::north);
-	BOOST_CHECK_EQUAL(camera.unProject({centre, centre}).start, ::origin);
+	BOOST_CHECK_EQUAL(camera.unProject({centre, centre}).start, RelativePosition3D {});
 	BOOST_CHECK_CLOSE_VEC(camera.unProject({centre, centre}).direction, ::north);
 	BOOST_CHECK_CLOSE_VEC(camera.unProject({left, centre}).direction, glm::normalize(::north + ::west));
 	BOOST_CHECK_CLOSE_VEC(camera.unProject({right, centre}).direction, glm::normalize(::north + ::east));
-- 
cgit v1.2.3