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

---
 game/geoData.cpp | 340 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 182 insertions(+), 158 deletions(-)

(limited to 'game/geoData.cpp')

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++));
 }
-- 
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/geoData.cpp')

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/geoData.cpp')

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/geoData.cpp')

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/geoData.cpp')

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/geoData.cpp')

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/geoData.cpp')

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 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/geoData.cpp')

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 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/geoData.cpp')

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/geoData.cpp')

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 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/geoData.cpp')

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/geoData.cpp')

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/geoData.cpp')

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 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/geoData.cpp')

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