From 3eed7751c9f2a7ae5cdba1d233751f82dd8d9b10 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Fri, 3 Nov 2023 21:31:35 +0000
Subject: Don't request a specific OpenGL version, just check we get something
 sufficient from gladLoadGL

---
 test/test-glContextBhvr.cpp | 2 +-
 ui/applicationBase.cpp      | 3 ---
 ui/window.cpp               | 8 +++-----
 3 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/test/test-glContextBhvr.cpp b/test/test-glContextBhvr.cpp
index 1f1215c..769f61f 100644
--- a/test/test-glContextBhvr.cpp
+++ b/test/test-glContextBhvr.cpp
@@ -29,7 +29,7 @@ BOOST_AUTO_TEST_CASE(windowContextThingsBehaviour1)
 			const SDL_GLContextPtr context {window};
 			BOOST_REQUIRE(context);
 			BOOST_REQUIRE(!glCreateProgram);
-			BOOST_REQUIRE_EQUAL(gladLoadGL(reinterpret_cast<GLADloadfunc>(SDL_GL_GetProcAddress)), 40006);
+			BOOST_REQUIRE_GT(gladLoadGL(reinterpret_cast<GLADloadfunc>(SDL_GL_GetProcAddress)), 0);
 			BOOST_REQUIRE(glCreateProgram);
 			CreateProgramTest();
 		} // Context destroyed
diff --git a/ui/applicationBase.cpp b/ui/applicationBase.cpp
index 32af3af..2be1f6c 100644
--- a/ui/applicationBase.cpp
+++ b/ui/applicationBase.cpp
@@ -21,9 +21,6 @@ ApplicationBase::ApplicationBase()
 	setGlAttribute(SDL_GL_DEPTH_SIZE, 16);
 	setGlAttribute(SDL_GL_DOUBLEBUFFER, 1);
 
-	setGlAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
-	setGlAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-	setGlAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
 	setGlAttribute(SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1);
 }
 
diff --git a/ui/window.cpp b/ui/window.cpp
index 93e85bd..6855aa0 100644
--- a/ui/window.cpp
+++ b/ui/window.cpp
@@ -1,17 +1,15 @@
 #include "window.h"
 #include "uiComponent.h"
-#include "worldOverlay.h"
 #include <glad/gl.h>
 #include <glm/glm.hpp>
 #include <stdexcept>
-#include <tuple>
-#include <type_traits>
 
 Window::GLInitHelper::GLInitHelper()
 {
 	[[maybe_unused]] static auto init = []() {
-		if (const auto version = gladLoadGL(reinterpret_cast<GLADloadfunc>(SDL_GL_GetProcAddress)); version != 40006) {
-			throw std::runtime_error {std::to_string(version)};
+		// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+		if (const auto version = gladLoadGL(reinterpret_cast<GLADloadfunc>(SDL_GL_GetProcAddress)); version < 30003) {
+			throw std::runtime_error {"Insufficient OpenGL version: " + std::to_string(version)};
 		}
 		else {
 			return version;
-- 
cgit v1.2.3


From 2f8d7643d03f39fa848576692264d0fe3a37ed91 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Mon, 6 Nov 2023 20:48:33 +0000
Subject: Reformat with new clang-format

---
 application/main.cpp             |  1 +
 assetFactory/assimp.cpp          |  1 +
 assetFactory/faceController.h    |  3 +++
 assetFactory/mutation.cpp        |  1 +
 assetFactory/object.h            |  1 +
 assetFactory/style.cpp           |  1 +
 assetFactory/texturePacker.h     |  2 ++
 assetFactory/use.cpp             |  1 +
 assetFactory/use.h               |  1 +
 game/activity.h                  |  2 ++
 game/gamestate.h                 |  1 +
 game/geoData.cpp                 |  1 +
 game/geoData.h                   |  1 +
 game/network/link.h              |  2 ++
 game/network/rail.cpp            |  1 +
 game/network/rail.h              |  2 ++
 game/objective.h                 |  2 ++
 game/orders.h                    |  1 +
 game/vehicles/railVehicle.h      |  1 +
 game/vehicles/railVehicleClass.h |  1 +
 game/vehicles/vehicle.h          |  1 +
 gfx/gl/camera.h                  |  8 ++++++++
 gfx/gl/instanceVertices.h        | 13 +++++++++++--
 gfx/gl/program.h                 |  3 +++
 gfx/gl/sceneProvider.cpp         |  1 +
 gfx/gl/sceneRenderer.cpp         |  1 +
 gfx/gl/sceneRenderer.h           |  2 ++
 gfx/gl/shader.h                  |  1 +
 gfx/gl/shadowMapper.cpp          |  7 +++++++
 gfx/gl/shadowMapper.h            |  5 +++++
 gfx/gl/uiShader.cpp              |  2 ++
 gfx/gl/vertexArrayObject.h       |  5 +++++
 gfx/image.h                      |  2 ++
 gfx/models/texture.cpp           |  2 ++
 gfx/models/tga.h                 |  1 +
 gfx/renderable.cpp               |  1 +
 lib/cache.h                      |  1 +
 lib/collections.h                |  3 +++
 lib/enumDetails.h                |  6 ++++++
 lib/glArrays.h                   |  3 ++-
 lib/glContainer.h                |  6 ++++++
 lib/gl_traits.h                  | 12 ++++++++++++
 lib/jsonParse-persistence.cpp    |  3 +++
 lib/maths.cpp                    |  6 ++++--
 lib/persistence.cpp              |  1 +
 lib/persistence.h                |  9 +++++++++
 lib/ptr.h                        |  1 +
 lib/resource.h                   |  1 +
 lib/saxParse-persistence.h       |  1 +
 lib/stdTypeDefs.h                |  4 ++++
 lib/unicode.h                    |  2 ++
 lib/worker.h                     |  3 +++
 test/enumDetailsData.h           |  3 +++
 test/test-assetFactory.cpp       | 11 +++++++++++
 test/test-collection.cpp         |  2 ++
 test/test-geo.cpp                |  7 +++++++
 test/test-glContainer.cpp        |  3 +++
 test/test-glContextBhvr.cpp      |  2 ++
 test/test-instancing.cpp         |  1 +
 test/test-lib.cpp                |  1 +
 test/test-maths.cpp              |  7 +++++++
 test/test-network.cpp            |  3 +++
 test/test-persistence.cpp        |  4 ++++
 test/test-render.cpp             |  9 +++++++++
 test/test-text.cpp               |  2 ++
 test/testMainWindow.h            |  1 +
 test/testRenderOutput.h          |  1 +
 ui/font.cpp                      |  1 +
 ui/font.h                        |  1 +
 ui/gameMainSelector.cpp          |  1 +
 ui/gameMainWindow.cpp            |  4 ++++
 ui/iconButton.h                  |  1 +
 ui/modeHelper.h                  |  1 +
 ui/text.cpp                      |  1 +
 ui/text.h                        |  1 +
 ui/uiComponent.cpp               |  1 +
 ui/uiComponent.h                 |  1 +
 ui/uiComponentPlacer.cpp         |  1 +
 ui/window.h                      |  1 +
 79 files changed, 211 insertions(+), 5 deletions(-)

diff --git a/application/main.cpp b/application/main.cpp
index 532c23d..0e880c0 100644
--- a/application/main.cpp
+++ b/application/main.cpp
@@ -34,6 +34,7 @@ static const int DISPLAY_HEIGHT = 1024;
 class MainApplication : public GameState, public ApplicationBase {
 public:
 	using Windows = Collection<Window>;
+
 	int
 	run()
 	{
diff --git a/assetFactory/assimp.cpp b/assetFactory/assimp.cpp
index 9dc7842..bd5467b 100644
--- a/assetFactory/assimp.cpp
+++ b/assetFactory/assimp.cpp
@@ -30,6 +30,7 @@ operator!(const aiVector3t<T> & v)
 	}
 
 using SceneCPtr = std::shared_ptr<const aiScene>;
+
 class AssImpNode : public Shape {
 public:
 	AssImpNode(SceneCPtr scene, const aiNode * node) : scene(std::move(scene)), node(node) { }
diff --git a/assetFactory/faceController.h b/assetFactory/faceController.h
index 0376241..fb89d25 100644
--- a/assetFactory/faceController.h
+++ b/assetFactory/faceController.h
@@ -18,12 +18,14 @@ public:
 	private:
 		friend Persistence::SelectionPtrBase<std::unique_ptr<Split>>;
 		bool persist(Persistence::PersistenceStore & store) override;
+
 		std::string
 		getId() const override
 		{
 			return {};
 		};
 	};
+
 	using FaceControllers = std::map<std::string, std::unique_ptr<FaceController>>;
 	using Splits = std::map<std::string, std::unique_ptr<Split>>;
 
@@ -38,6 +40,7 @@ public:
 private:
 	friend Persistence::SelectionPtrBase<std::unique_ptr<FaceController>>;
 	bool persist(Persistence::PersistenceStore & store) override;
+
 	std::string
 	getId() const override
 	{
diff --git a/assetFactory/mutation.cpp b/assetFactory/mutation.cpp
index 9a6a988..c5c3f5b 100644
--- a/assetFactory/mutation.cpp
+++ b/assetFactory/mutation.cpp
@@ -27,6 +27,7 @@ Mutation::relativeLevelOfDetail() const
 {
 	return std::max({scale.x, scale.y, scale.z});
 }
+
 bool
 Mutation::persist(Persistence::PersistenceStore & store)
 {
diff --git a/assetFactory/object.h b/assetFactory/object.h
index f47c512..77e1469 100644
--- a/assetFactory/object.h
+++ b/assetFactory/object.h
@@ -18,6 +18,7 @@ public:
 private:
 	friend Persistence::SelectionPtrBase<std::shared_ptr<Object>>;
 	bool persist(Persistence::PersistenceStore & store) override;
+
 	std::string
 	getId() const override
 	{
diff --git a/assetFactory/style.cpp b/assetFactory/style.cpp
index ea67fc2..81a5441 100644
--- a/assetFactory/style.cpp
+++ b/assetFactory/style.cpp
@@ -61,6 +61,7 @@ Style::persist(Persistence::PersistenceStore & store)
 	struct ColourParser : public Persistence::SelectionV<ColourAlpha> {
 		using Persistence::SelectionV<ColourAlpha>::SelectionV;
 		using Persistence::SelectionV<ColourAlpha>::setValue;
+
 		void
 		setValue(std::string && str) override
 		{
diff --git a/assetFactory/texturePacker.h b/assetFactory/texturePacker.h
index a1b270b..93413eb 100644
--- a/assetFactory/texturePacker.h
+++ b/assetFactory/texturePacker.h
@@ -16,12 +16,14 @@ public:
 
 		Position position;
 		Size size;
+
 		bool
 		operator<(const Area & other) const
 		{
 			return area(size) < area(other.size);
 		}
 	};
+
 	using Image = Size;
 	using Space = Area;
 	using Positions = std::vector<Position>;
diff --git a/assetFactory/use.cpp b/assetFactory/use.cpp
index 5314321..0994c8c 100644
--- a/assetFactory/use.cpp
+++ b/assetFactory/use.cpp
@@ -35,6 +35,7 @@ Use::createMesh(ModelFactoryMesh & mesh, float levelOfDetailFactor) const
 struct Lookup : public Persistence::SelectionV<Shape::CPtr> {
 	using Persistence::SelectionV<Shape::CPtr>::SelectionV;
 	using Persistence::SelectionV<Shape::CPtr>::setValue;
+
 	void
 	setValue(std::string && str) override
 	{
diff --git a/assetFactory/use.h b/assetFactory/use.h
index a91685b..289bf6e 100644
--- a/assetFactory/use.h
+++ b/assetFactory/use.h
@@ -19,6 +19,7 @@ public:
 private:
 	friend Persistence::SelectionPtrBase<std::shared_ptr<Use>>;
 	bool persist(Persistence::PersistenceStore & store) override;
+
 	std::string
 	getId() const override
 	{
diff --git a/game/activity.h b/game/activity.h
index e0585f7..38f6524 100644
--- a/game/activity.h
+++ b/game/activity.h
@@ -16,10 +16,12 @@ public:
 
 	template<typename T> class Of;
 };
+
 using ActivityPtr = std::unique_ptr<Activity>;
 
 template<typename T>
 concept ActivityConcept = std::is_base_of_v<Activity, T>;
+
 template<ActivityConcept AC> class Can {
 public:
 	Can() = default;
diff --git a/game/gamestate.h b/game/gamestate.h
index 6f3f382..f07f844 100644
--- a/game/gamestate.h
+++ b/game/gamestate.h
@@ -19,4 +19,5 @@ public:
 	std::shared_ptr<GeoData> geoData;
 	AssetFactory::Assets assets;
 };
+
 extern GameState * gameState;
diff --git a/game/geoData.cpp b/game/geoData.cpp
index 34a1030..76550cc 100644
--- a/game/geoData.cpp
+++ b/game/geoData.cpp
@@ -100,6 +100,7 @@ GeoData::positionAt(const glm::vec2 wcoord) const
 }
 
 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)}
 {
diff --git a/game/geoData.h b/game/geoData.h
index f433a5c..f9a7d7b 100644
--- a/game/geoData.h
+++ b/game/geoData.h
@@ -15,6 +15,7 @@ public:
 	struct Node {
 		float height {-1.5F};
 	};
+
 	using Quad = std::array<glm::vec3, 4>;
 
 	using Limits = std::pair<glm::ivec2, glm::ivec2>;
diff --git a/game/network/link.h b/game/network/link.h
index 4a9f83f..0d66c42 100644
--- a/game/network/link.h
+++ b/game/network/link.h
@@ -71,6 +71,7 @@ public:
 	[[nodiscard]] Location positionAt(float dist, unsigned char start) const override;
 	[[nodiscard]] bool intersectRay(const Ray &) const override;
 };
+
 LinkStraight::~LinkStraight() = default;
 
 class LinkCurve : public virtual Link {
@@ -87,4 +88,5 @@ public:
 	float radius;
 	Arc arc;
 };
+
 LinkCurve::~LinkCurve() = default;
diff --git a/game/network/rail.cpp b/game/network/rail.cpp
index bd24a2b..5a4f1e1 100644
--- a/game/network/rail.cpp
+++ b/game/network/rail.cpp
@@ -21,6 +21,7 @@ constexpr auto RAIL_CROSSSECTION_VERTICES {5U};
 constexpr glm::vec3 RAIL_HEIGHT {0, 0, .25F};
 
 RailLinks::RailLinks() : NetworkOf<RailLink> {"rails.jpg"} { }
+
 void
 RailLinks::tick(TickDuration)
 {
diff --git a/game/network/rail.h b/game/network/rail.h
index 611eb67..6684801 100644
--- a/game/network/rail.h
+++ b/game/network/rail.h
@@ -18,6 +18,7 @@ struct Arc;
 // A piece of rail track
 class RailLinkStraight;
 class RailLinkCurve;
+
 class RailLink : public virtual Link, public Renderable {
 public:
 	RailLink() = default;
@@ -36,6 +37,7 @@ protected:
 
 	Mesh::Ptr mesh;
 };
+
 RailLink::~RailLink() = default;
 
 class RailLinkStraight : public RailLink, public LinkStraight {
diff --git a/game/objective.h b/game/objective.h
index 130015f..f5c6e48 100644
--- a/game/objective.h
+++ b/game/objective.h
@@ -10,6 +10,7 @@ class Orders;
 class Objective {
 public:
 	explicit Objective(Orders * os) : orders(os) { }
+
 	DEFAULT_MOVE_COPY(Objective);
 	virtual ~Objective() = default;
 
@@ -19,4 +20,5 @@ public:
 
 	Orders * orders;
 };
+
 using ObjectivePtr = std::unique_ptr<Objective>;
diff --git a/game/orders.h b/game/orders.h
index f29e208..ca5cfdb 100644
--- a/game/orders.h
+++ b/game/orders.h
@@ -10,4 +10,5 @@ public:
 	[[nodiscard]] Objective * current() const;
 	Objective * next();
 };
+
 using OrdersPtr = std::shared_ptr<Orders>;
diff --git a/game/vehicles/railVehicle.h b/game/vehicles/railVehicle.h
index f34643e..be88142 100644
--- a/game/vehicles/railVehicle.h
+++ b/game/vehicles/railVehicle.h
@@ -25,4 +25,5 @@ public:
 	BLocation location;
 	std::array<BLocation, 2> bogies;
 };
+
 using RailVehiclePtr = std::unique_ptr<RailVehicle>;
diff --git a/game/vehicles/railVehicleClass.h b/game/vehicles/railVehicleClass.h
index 80b3fda..4668d7d 100644
--- a/game/vehicles/railVehicleClass.h
+++ b/game/vehicles/railVehicleClass.h
@@ -41,4 +41,5 @@ private:
 	glVertexArray instanceVAO;
 	std::array<glVertexArray, 2> instancesBogiesVAO;
 };
+
 using RailVehicleClassPtr = std::shared_ptr<RailVehicleClass>;
diff --git a/game/vehicles/vehicle.h b/game/vehicles/vehicle.h
index 763ade9..354f904 100644
--- a/game/vehicles/vehicle.h
+++ b/game/vehicles/vehicle.h
@@ -27,4 +27,5 @@ protected:
 	void move(TickDuration dur);
 	LinkHistory linkHist;
 };
+
 using VehicleWPtr = std::weak_ptr<Vehicle>;
diff --git a/gfx/gl/camera.h b/gfx/gl/camera.h
index 3f1c3a7..7956ec3 100644
--- a/gfx/gl/camera.h
+++ b/gfx/gl/camera.h
@@ -13,6 +13,7 @@ public:
 	{
 		return viewProjection;
 	}
+
 	[[nodiscard]] Ray unProject(const glm::vec2 &) const;
 
 	void
@@ -21,11 +22,13 @@ public:
 		position = p;
 		updateView();
 	}
+
 	void
 	setForward(const glm::vec3 & f)
 	{
 		setForward(f, upFromForward(f));
 	}
+
 	void
 	setForward(const glm::vec3 & f, const glm::vec3 & u)
 	{
@@ -33,28 +36,33 @@ public:
 		up = u;
 		updateView();
 	}
+
 	void
 	setView(const glm::vec3 & p, const glm::vec3 & f)
 	{
 		position = p;
 		setForward(f);
 	}
+
 	void
 	setView(const glm::vec3 & p, const glm::vec3 & f, const glm::vec3 & u)
 	{
 		position = p;
 		setView(f, u);
 	}
+
 	void
 	lookAt(const glm::vec3 & target)
 	{
 		setForward(glm::normalize(target - position));
 	}
+
 	[[nodiscard]] auto
 	getForward() const
 	{
 		return forward;
 	}
+
 	[[nodiscard]] auto
 	getPosition() const
 	{
diff --git a/gfx/gl/instanceVertices.h b/gfx/gl/instanceVertices.h
index 7b0341b..a89aa78 100644
--- a/gfx/gl/instanceVertices.h
+++ b/gfx/gl/instanceVertices.h
@@ -13,9 +13,11 @@ public:
 	class [[nodiscard]] InstanceProxy {
 	public:
 		InstanceProxy(InstanceVertices * iv, std::size_t idx) : instances {iv}, index {idx} { }
+
 		InstanceProxy(InstanceProxy && other) : instances {std::exchange(other.instances, nullptr)}, index {other.index}
 		{
 		}
+
 		NO_COPY(InstanceProxy);
 
 		~InstanceProxy()
@@ -35,6 +37,7 @@ public:
 			index = other.index;
 			return *this;
 		}
+
 		template<typename U>
 		T &
 		operator=(U && v)
@@ -42,40 +45,46 @@ public:
 			return instances->lookup(index) = std::forward<U>(v);
 		}
 
-		[[nodiscard]]
-		operator T &()
+		[[nodiscard]] operator T &()
 		{
 			return instances->lookup(index);
 		}
+
 		[[nodiscard]] operator const T &() const
 		{
 			return instances->lookup(index);
 		}
+
 		[[nodiscard]] T *
 		get()
 		{
 			return &instances->lookup(index);
 		}
+
 		[[nodiscard]] const T *
 		get() const
 		{
 			return &instances->lookup(index);
 		}
+
 		[[nodiscard]] T *
 		operator->()
 		{
 			return get();
 		}
+
 		[[nodiscard]] const T *
 		operator->() const
 		{
 			return get();
 		}
+
 		[[nodiscard]] T &
 		operator*()
 		{
 			return instances->lookup(index);
 		}
+
 		[[nodiscard]] const T &
 		operator*() const
 		{
diff --git a/gfx/gl/program.h b/gfx/gl/program.h
index 76b6742..1a1c306 100644
--- a/gfx/gl/program.h
+++ b/gfx/gl/program.h
@@ -9,6 +9,7 @@
 class Location;
 
 using ProgramRef = glRef<GLuint, &glCreateProgram, &glDeleteProgram>;
+
 class Program {
 public:
 	template<typename... S> explicit Program(const S &... srcs)
@@ -16,12 +17,14 @@ public:
 		(glAttachShader(m_program, srcs.compile()), ...);
 		linkAndValidate();
 	}
+
 	virtual ~Program() = default;
 	DEFAULT_MOVE_NO_COPY(Program);
 
 	class UniformLocation {
 	public:
 		UniformLocation(GLuint prog, const char * name);
+
 		// NOLINTNEXTLINE(hicpp-explicit-conversions)
 		operator auto() const
 		{
diff --git a/gfx/gl/sceneProvider.cpp b/gfx/gl/sceneProvider.cpp
index 0163b36..2e8604c 100644
--- a/gfx/gl/sceneProvider.cpp
+++ b/gfx/gl/sceneProvider.cpp
@@ -7,6 +7,7 @@ SceneProvider::environment(const SceneShader &, const SceneRenderer & renderer)
 	renderer.setAmbientLight({0.5F, 0.5F, 0.5F});
 	renderer.setDirectionalLight({0.6F, 0.6F, 0.6F}, {-1, 1, -1}, *this);
 }
+
 void
 SceneProvider::shadows(const ShadowMapper &) const
 {
diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index aa9453a..5799daf 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -13,6 +13,7 @@ static constexpr const std::array<const glm::i8vec4, 4> displayVAOdata {{
 		{1, 1, 1, 1},
 		{1, -1, 1, 0},
 }};
+
 SceneRenderer::SceneRenderer(glm::ivec2 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 d4af665..55df84d 100644
--- a/gfx/gl/sceneRenderer.h
+++ b/gfx/gl/sceneRenderer.h
@@ -27,11 +27,13 @@ private:
 	glFrameBuffer gBuffer;
 	glTexture gPosition, gNormal, gAlbedoSpec, gIllumination;
 	glRenderBuffer depth;
+
 	class DeferredLightProgram : public Program {
 	public:
 		using Program::Program;
 		using Program::use;
 	};
+
 	class DirectionalLightProgram : public Program {
 	public:
 		DirectionalLightProgram();
diff --git a/gfx/gl/shader.h b/gfx/gl/shader.h
index 0810e6b..cff2281 100644
--- a/gfx/gl/shader.h
+++ b/gfx/gl/shader.h
@@ -8,6 +8,7 @@
 class Shader {
 public:
 	using ShaderRef = glRef<GLuint, &glCreateShader, &glDeleteShader>;
+
 	constexpr Shader(const GLchar * text, GLint len, GLuint type) : text {text}, len {len}, type {type} { }
 
 	[[nodiscard]] ShaderRef compile() const;
diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 55d986c..79b39c0 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -94,11 +94,13 @@ struct DefinitionsInserter {
 	{
 		return out.maps++;
 	};
+
 	auto
 	operator*()
 	{
 		return std::tie(out.projections[out.maps], out.regions[out.maps]);
 	}
+
 	ShadowMapper::Definitions & out;
 };
 
@@ -161,12 +163,14 @@ ShadowMapper::update(const SceneProvider & scene, const glm::vec3 & dir, const C
 }
 
 ShadowMapper::FixedPoint::FixedPoint(const Shader & vs) : Program {vs}, viewProjectionLoc {*this, "viewProjection"} { }
+
 void
 ShadowMapper::FixedPoint::setViewProjection(const glm::mat4 & viewProjection) const
 {
 	use();
 	glUniformMatrix4fv(viewProjectionLoc, 1, GL_FALSE, glm::value_ptr(viewProjection));
 }
+
 void
 ShadowMapper::FixedPoint::use() const
 {
@@ -177,12 +181,14 @@ ShadowMapper::DynamicPoint::DynamicPoint() :
 	Program {shadowDynamicPoint_vs}, viewProjectionLoc {*this, "viewProjection"}, modelLoc {*this, "model"}
 {
 }
+
 void
 ShadowMapper::DynamicPoint::setViewProjection(const glm::mat4 & viewProjection) const
 {
 	glUseProgram(*this);
 	glUniformMatrix4fv(viewProjectionLoc, 1, GL_FALSE, glm::value_ptr(viewProjection));
 }
+
 void
 ShadowMapper::DynamicPoint::use(const Location & location) const
 {
@@ -191,6 +197,7 @@ ShadowMapper::DynamicPoint::use(const Location & location) const
 	const auto model = glm::translate(location.pos) * rotate_ypr(location.rot);
 	glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
 }
+
 void
 ShadowMapper::DynamicPoint::setModel(const Location & location) const
 {
diff --git a/gfx/gl/shadowMapper.h b/gfx/gl/shadowMapper.h
index 36371eb..cd1b975 100644
--- a/gfx/gl/shadowMapper.h
+++ b/gfx/gl/shadowMapper.h
@@ -8,16 +8,19 @@ class SceneProvider;
 class Camera;
 
 #include <gfx/models/texture.h>
+
 class ShadowMapper {
 public:
 	explicit ShadowMapper(const glm::ivec2 & size);
 
 	static constexpr std::size_t SHADOW_BANDS {4};
+
 	struct Definitions {
 		std::array<glm::mat4x4, SHADOW_BANDS> projections {};
 		std::array<glm::vec4, SHADOW_BANDS> regions {};
 		size_t maps {};
 	};
+
 	[[nodiscard]] Definitions update(const SceneProvider &, const glm::vec3 & direction, const Camera &) const;
 
 	class FixedPoint : public Program {
@@ -29,6 +32,7 @@ public:
 	private:
 		RequiredUniformLocation viewProjectionLoc;
 	};
+
 	class DynamicPoint : public Program {
 	public:
 		DynamicPoint();
@@ -40,6 +44,7 @@ public:
 		RequiredUniformLocation viewProjectionLoc;
 		RequiredUniformLocation modelLoc;
 	};
+
 	FixedPoint fixedPoint, dynamicPointInst;
 	DynamicPoint dynamicPoint;
 
diff --git a/gfx/gl/uiShader.cpp b/gfx/gl/uiShader.cpp
index 78e0064..0b47211 100644
--- a/gfx/gl/uiShader.cpp
+++ b/gfx/gl/uiShader.cpp
@@ -9,6 +9,7 @@
 #include <initializer_list>
 
 UIShader::IconProgram::IconProgram(const glm::mat4 & vp) : UIProgram {vp, uiShader_vs, uiShader_fs} { }
+
 UIShader::TextProgram::TextProgram(const glm::mat4 & vp) :
 	UIProgram {vp, uiShader_vs, uiShaderFont_fs}, colorLoc {*this, "colour"}
 {
@@ -18,6 +19,7 @@ UIShader::UIShader(size_t width, size_t height) :
 	UIShader {glm::ortho<float>(0, static_cast<float>(width), 0, static_cast<float>(height))}
 {
 }
+
 UIShader::UIShader(const glm::mat4 & viewProjection) : icon {viewProjection}, text {viewProjection} { }
 
 void
diff --git a/gfx/gl/vertexArrayObject.h b/gfx/gl/vertexArrayObject.h
index fa6baa3..57daaf3 100644
--- a/gfx/gl/vertexArrayObject.h
+++ b/gfx/gl/vertexArrayObject.h
@@ -11,22 +11,27 @@ public:
 	{
 		glBindVertexArray(arrayObject);
 	}
+
 	~VertexArrayObject()
 	{
 		glBindVertexArray(0);
 	}
+
 	NO_MOVE(VertexArrayObject);
 	NO_COPY(VertexArrayObject);
 
 	template<typename m, typename T> struct MP {
 		constexpr MP(m T::*p) : P {p} { }
+
 		operator void *() const
 		{
 			return &(static_cast<T *>(nullptr)->*P);
 		}
+
 		m T::*P;
 		using value_type = m;
 	};
+
 	template<typename m, typename T> MP(m T::*) -> MP<m, T>;
 
 	template<typename VertexT, MP... attribs>
diff --git a/gfx/image.h b/gfx/image.h
index 8bb4067..6fbbdd1 100644
--- a/gfx/image.h
+++ b/gfx/image.h
@@ -7,7 +7,9 @@
 class Image {
 public:
 	Image(const char * fileName, int flags);
+
 	Image(const std::string & fileName, int flags) : Image(fileName.c_str(), flags) { }
+
 	Image(std::span<unsigned char> data, int flags);
 	~Image();
 
diff --git a/gfx/models/texture.cpp b/gfx/models/texture.cpp
index 380f2e0..b7f1bee 100644
--- a/gfx/models/texture.cpp
+++ b/gfx/models/texture.cpp
@@ -139,11 +139,13 @@ GLuint
 TextureAtlas::add(glm::ivec2 position, glm::ivec2 size, void * data, TextureOptions to)
 {
 	glTextureSubImage2D(m_texture, 0, position.x, position.y, size.x, size.y, GL_RGBA, GL_UNSIGNED_BYTE, data);
+
 	struct Material {
 		glm::vec<2, uint16_t> position, size;
 		TextureOptions::MapMode wrapU;
 		TextureOptions::MapMode wrapV;
 	} material {position, size, to.wrapU, to.wrapV};
+
 	static_assert(sizeof(Material) <= 32);
 	glTextureSubImage2D(m_atlas, 0, 0, static_cast<GLsizei>(used), 2, 1, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, &material);
 	return ++used;
diff --git a/gfx/models/tga.h b/gfx/models/tga.h
index 1f400ef..52db220 100644
--- a/gfx/models/tga.h
+++ b/gfx/models/tga.h
@@ -11,4 +11,5 @@ struct TGAHead {
 	uint8_t pixelDepth {};
 	uint8_t descriptor {};
 };
+
 static_assert(sizeof(TGAHead) == 18);
diff --git a/gfx/renderable.cpp b/gfx/renderable.cpp
index 539efb1..0340189 100644
--- a/gfx/renderable.cpp
+++ b/gfx/renderable.cpp
@@ -4,6 +4,7 @@ void
 Renderable::lights(const SceneShader &) const
 {
 }
+
 void
 Renderable::shadows(const ShadowMapper &) const
 {
diff --git a/lib/cache.h b/lib/cache.h
index 2c3975b..f5fd227 100644
--- a/lib/cache.h
+++ b/lib/cache.h
@@ -35,4 +35,5 @@ public:
 private:
 	std::map<Key, Ptr, std::less<>> cached;
 };
+
 // IWYU pragma: no_forward_declare Cache
diff --git a/lib/collections.h b/lib/collections.h
index 7d78ef9..943b986 100644
--- a/lib/collections.h
+++ b/lib/collections.h
@@ -149,11 +149,14 @@ template<typename T> struct pair_range {
 	{
 		return pair.first;
 	}
+
 	constexpr auto &
 	end() const noexcept
 	{
 		return pair.second;
 	}
+
 	const std::pair<T, T> & pair;
 };
+
 template<typename T> pair_range(std::pair<T, T>) -> pair_range<T>;
diff --git a/lib/enumDetails.h b/lib/enumDetails.h
index 5966be2..b6ff046 100644
--- a/lib/enumDetails.h
+++ b/lib/enumDetails.h
@@ -26,11 +26,13 @@ template<typename E> struct EnumTypeDetails : EnumDetailsBase {
 protected:
 #endif
 	constexpr static std::string_view SEARCH_TYPE {"E = "};
+
 	constexpr static auto
 	typeraw()
 	{
 		return std::string_view {__PRETTY_FUNCTION__};
 	};
+
 	constexpr static auto typeNameStart {typeraw().find(SEARCH_TYPE) + SEARCH_TYPE.length()};
 	constexpr static auto typeNameEnd {typeraw().find_first_of("];", typeNameStart)};
 	constexpr static auto typeNameLen {typeNameEnd - typeNameStart};
@@ -47,11 +49,13 @@ template<auto value> struct EnumValueDetails : public EnumTypeDetails<decltype(v
 private:
 #endif
 	using T = EnumTypeDetails<decltype(value)>;
+
 	constexpr static auto
 	raw()
 	{
 		return std::string_view {__PRETTY_FUNCTION__};
 	};
+
 	constexpr static auto nameStart {raw().find_last_of(": ") + 1};
 	constexpr static auto nameEnd {raw().find_first_of("];", nameStart)};
 	constexpr static auto nameLen {nameEnd - nameStart};
@@ -84,12 +88,14 @@ private:
 		return std::array {EnumValueDetails<static_cast<E>(n)>::valid...};
 #pragma GCC diagnostic pop
 	}
+
 	template<auto... n>
 	constexpr static auto
 	get_values(std::integer_sequence<int, n...>)
 	{
 		return std::array {EnumValueDetails<static_cast<E>(n)>::raw_value...};
 	}
+
 	template<auto... n>
 	constexpr static auto
 	get_valueNames(std::integer_sequence<int, n...>)
diff --git a/lib/glArrays.h b/lib/glArrays.h
index 86385d9..787ea17 100644
--- a/lib/glArrays.h
+++ b/lib/glArrays.h
@@ -15,7 +15,8 @@ public:
 	CUSTOM_MOVE(glArraysBase);
 
 	// NOLINTNEXTLINE(hicpp-explicit-conversions)
-	inline operator GLuint() const
+	inline
+	operator GLuint() const
 	{
 		static_assert(N == 1, "Implicit cast only if N == 1");
 		return ids.front();
diff --git a/lib/glContainer.h b/lib/glContainer.h
index 993170e..8177618 100644
--- a/lib/glContainer.h
+++ b/lib/glContainer.h
@@ -9,6 +9,7 @@
 template<typename I, typename Direction> class basic_glContainer_iterator {
 public:
 	explicit basic_glContainer_iterator(I * i) : i {i} { }
+
 	template<typename OtherI>
 	basic_glContainer_iterator(const basic_glContainer_iterator<OtherI, Direction> & other) : i {&*other}
 	{
@@ -20,17 +21,20 @@ public:
 		i = Direction {}(i, 1);
 		return *this;
 	}
+
 	auto
 	operator++(int) noexcept
 	{
 		return basic_glContainer_iterator<I, Direction> {std::exchange(i, Direction {}(i, 1))};
 	}
+
 	auto &
 	operator--() noexcept
 	{
 		i = Direction {}(i, -1);
 		return *this;
 	}
+
 	auto
 	operator--(int) noexcept
 	{
@@ -76,6 +80,7 @@ public:
 	{
 		return this->i == other.i;
 	}
+
 	[[nodiscard]] bool
 	operator!=(const basic_glContainer_iterator & other) const noexcept
 	{
@@ -87,6 +92,7 @@ public:
 	{
 		return i;
 	}
+
 	[[nodiscard]] auto &
 	operator*() const noexcept
 	{
diff --git a/lib/gl_traits.h b/lib/gl_traits.h
index a930eba..934b505 100644
--- a/lib/gl_traits.h
+++ b/lib/gl_traits.h
@@ -6,9 +6,11 @@
 #include <glm/fwd.hpp>
 
 template<typename T> struct gl_traits;
+
 struct gl_traits_base {
 	static constexpr GLint size {1};
 };
+
 struct gl_traits_float : public gl_traits_base {
 	static constexpr auto vertexAttribFunc {
 			[](GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) -> GLuint {
@@ -16,6 +18,7 @@ struct gl_traits_float : public gl_traits_base {
 				return 1;
 			}};
 };
+
 struct gl_traits_longfloat : public gl_traits_base {
 	static constexpr auto vertexAttribFunc {
 			[](GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) -> GLuint {
@@ -23,6 +26,7 @@ struct gl_traits_longfloat : public gl_traits_base {
 				return 1;
 			}};
 };
+
 struct gl_traits_integer : public gl_traits_base {
 	static constexpr auto vertexAttribFunc {
 			[](GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) -> GLuint {
@@ -30,27 +34,35 @@ struct gl_traits_integer : public gl_traits_base {
 				return 1;
 			}};
 };
+
 template<> struct gl_traits<glm::f32> : public gl_traits_float {
 	static constexpr GLenum type {GL_FLOAT};
 };
+
 template<> struct gl_traits<glm::f64> : public gl_traits_longfloat {
 	static constexpr GLenum type {GL_DOUBLE};
 };
+
 template<> struct gl_traits<glm::int8> : public gl_traits_integer {
 	static constexpr GLenum type {GL_BYTE};
 };
+
 template<> struct gl_traits<glm::int16> : public gl_traits_integer {
 	static constexpr GLenum type {GL_SHORT};
 };
+
 template<> struct gl_traits<glm::int32> : public gl_traits_integer {
 	static constexpr GLenum type {GL_INT};
 };
+
 template<> struct gl_traits<glm::uint8> : public gl_traits_integer {
 	static constexpr GLenum type {GL_UNSIGNED_BYTE};
 };
+
 template<> struct gl_traits<glm::uint16> : public gl_traits_integer {
 	static constexpr GLenum type {GL_UNSIGNED_SHORT};
 };
+
 template<> struct gl_traits<glm::uint32> : public gl_traits_integer {
 	static constexpr GLenum type {GL_UNSIGNED_INT};
 };
diff --git a/lib/jsonParse-persistence.cpp b/lib/jsonParse-persistence.cpp
index fe8bf8d..5c0011a 100644
--- a/lib/jsonParse-persistence.cpp
+++ b/lib/jsonParse-persistence.cpp
@@ -93,17 +93,20 @@ namespace Persistence {
 	{
 		strm.put(ch);
 	}
+
 	static inline void
 	wrh(std::ostream & strm, char ch)
 	{
 		using namespace std::literals;
 		strm << R"(\u)"sv << std::setw(4) << std::hex << static_cast<int>(ch) << std::setw(1);
 	}
+
 	static inline void
 	wre(std::ostream & strm, char e)
 	{
 		strm << '\\' << e;
 	}
+
 	template<char E>
 	static inline void
 	wre(std::ostream & strm, char)
diff --git a/lib/maths.cpp b/lib/maths.cpp
index b8dbd34..7594b59 100644
--- a/lib/maths.cpp
+++ b/lib/maths.cpp
@@ -177,12 +177,14 @@ find_arcs_radius(glm::vec2 start, glm::vec2 ad, glm::vec2 end, glm::vec2 bd)
 			/ (2 * (sq(X) - 2 * X * Z + sq(Z) + sq(Y) - 2 * Y * W + sq(W) - 4));
 }
 
-float operator"" _mph(const long double v)
+float
+operator"" _mph(const long double v)
 {
 	return static_cast<float>(mph_to_ms(v));
 }
 
-float operator"" _kph(const long double v)
+float
+operator"" _kph(const long double v)
 {
 	return static_cast<float>(kph_to_ms(v));
 }
diff --git a/lib/persistence.cpp b/lib/persistence.cpp
index e22d74d..38e2ac6 100644
--- a/lib/persistence.cpp
+++ b/lib/persistence.cpp
@@ -167,6 +167,7 @@ namespace Persistence {
 	{
 		throw std::logic_error("Default write op shouldn't ever get called");
 	}
+
 	/// LCOV_EXCL_STOP
 
 	ParseBase::ParseBase() : sharedObjectsInstance {std::make_shared<SharedObjects>()}
diff --git a/lib/persistence.h b/lib/persistence.h
index 5d71d4c..92f3052 100644
--- a/lib/persistence.h
+++ b/lib/persistence.h
@@ -153,6 +153,7 @@ namespace Persistence {
 	};
 
 	struct Persistable;
+
 	struct PersistenceStore {
 		using SelectionFactory = std::function<SelectionPtr()>;
 		PersistenceStore() = default;
@@ -163,6 +164,7 @@ namespace Persistence {
 
 		enum class NameAction { Push, HandleAndContinue, Ignore };
 		using NameActionSelection = std::pair<NameAction, SelectionPtr>;
+
 		template<typename Helper, typename T>
 		[[nodiscard]] inline bool
 		persistValue(const std::string_view key, T & value)
@@ -267,6 +269,7 @@ namespace Persistence {
 	template<glm::length_t L, typename T, glm::qualifier Q>
 	struct SelectionT<glm::vec<L, T, Q>> : public SelectionT<std::span<T>> {
 		SelectionT(glm::vec<L, T, Q> & v) : SelectionT<std::span<T>> {spn}, spn {&v[0], L} { }
+
 		std::span<T> spn;
 	};
 
@@ -316,6 +319,7 @@ namespace Persistence {
 		MapByMember(Map & m) : Persistence::SelectionT<Type> {s}, map {m} { }
 
 		using Persistence::SelectionT<Type>::SelectionT;
+
 		void
 		endObject(Persistence::Stack & stk) override
 		{
@@ -332,7 +336,9 @@ namespace Persistence {
 	template<typename Container, typename Type = typename Container::value_type>
 	struct Appender : public Persistence::SelectionT<Type> {
 		Appender(Container & c) : Persistence::SelectionT<Type> {s}, container {c} { }
+
 		using Persistence::SelectionT<Type>::SelectionT;
+
 		void
 		endObject(Persistence::Stack & stk) override
 		{
@@ -407,6 +413,7 @@ namespace Persistence {
 		{
 			return std::dynamic_pointer_cast<T>(Persistence::ParseBase::sharedObjects.lock()->at(k));
 		}
+
 		template<typename... T>
 		static auto
 		emplaceShared(T &&... v)
@@ -421,6 +428,7 @@ namespace Persistence {
 		inline static thread_local SharedObjectsWPtr sharedObjects;
 		SharedObjectsPtr sharedObjectsInstance;
 	};
+
 	// TODO Move these
 	using SeenSharedObjects = std::map<void *, std::string>;
 	inline SeenSharedObjects seenSharedObjects;
@@ -428,6 +436,7 @@ namespace Persistence {
 	template<typename Ptr> struct SelectionPtrBase : public SelectionV<Ptr> {
 		static constexpr auto shared = std::is_copy_assignable_v<Ptr>;
 		using T = typename Ptr::element_type;
+
 		struct SelectionObj : public SelectionV<Ptr> {
 			struct MakeObjectByTypeName : public SelectionV<Ptr> {
 				using SelectionV<Ptr>::SelectionV;
diff --git a/lib/ptr.h b/lib/ptr.h
index b7d15a1..fb959ab 100644
--- a/lib/ptr.h
+++ b/lib/ptr.h
@@ -55,6 +55,7 @@ public:
 
 protected:
 	explicit wrapped_ptr(Obj * o) : obj {o} { }
+
 	Obj * obj;
 };
 
diff --git a/lib/resource.h b/lib/resource.h
index 37dd657..9af3632 100644
--- a/lib/resource.h
+++ b/lib/resource.h
@@ -16,5 +16,6 @@ public:
 		Resource::setBasePath(RESDIR);
 	}
 };
+
 BOOST_GLOBAL_FIXTURE(SetResourcePath);
 #endif
diff --git a/lib/saxParse-persistence.h b/lib/saxParse-persistence.h
index 6043b25..bd5db57 100644
--- a/lib/saxParse-persistence.h
+++ b/lib/saxParse-persistence.h
@@ -10,6 +10,7 @@ namespace Persistence {
 	private:
 		template<typename T> struct Root : public Persistable {
 			T t {};
+
 			bool
 			persist(PersistenceStore & store)
 			{
diff --git a/lib/stdTypeDefs.h b/lib/stdTypeDefs.h
index 317cdb3..beab630 100644
--- a/lib/stdTypeDefs.h
+++ b/lib/stdTypeDefs.h
@@ -6,18 +6,22 @@
 template<typename T> struct AnyPtr {
 	// cppcheck-suppress noExplicitConstructor
 	AnyPtr(T * p) : ptr {p} { }
+
 	// cppcheck-suppress noExplicitConstructor
 	template<typename S> AnyPtr(const S & p) : ptr {p.get()} { }
+
 	auto
 	get() const
 	{
 		return ptr;
 	}
+
 	auto
 	operator->() const
 	{
 		return ptr;
 	}
+
 	auto &
 	operator*() const
 	{
diff --git a/lib/unicode.h b/lib/unicode.h
index f69c43c..bc491f3 100644
--- a/lib/unicode.h
+++ b/lib/unicode.h
@@ -50,6 +50,7 @@ struct utf8_string_view {
 	constexpr utf8_string_view(const Str & str) : begin_ {str.data()}, end_ {str.data() + str.length()}
 	{
 	}
+
 	// cppcheck-suppress noExplicitConstructor; NOLINTNEXTLINE(hicpp-explicit-conversions)
 	constexpr utf8_string_view(const char * const str) : utf8_string_view {std::string_view {str}} { }
 
@@ -70,6 +71,7 @@ struct utf8_string_view {
 private:
 	const char *begin_, *end_;
 };
+
 template<> struct std::iterator_traits<utf8_string_view::iter> {
 	using difference_type = size_t;
 	using value_type = uint32_t;
diff --git a/lib/worker.h b/lib/worker.h
index 0d15ca2..95bb4ec 100644
--- a/lib/worker.h
+++ b/lib/worker.h
@@ -16,6 +16,7 @@ public:
 	class WorkItem {
 	protected:
 		WorkItem(Worker * worker) : worker {worker} { }
+
 		virtual ~WorkItem() = default;
 		NO_MOVE(WorkItem);
 		NO_COPY(WorkItem);
@@ -25,6 +26,7 @@ public:
 		{
 			worker->assist();
 		}
+
 		Worker * worker;
 
 	public:
@@ -57,6 +59,7 @@ public:
 	{
 		return instance.addWorkImpl(std::forward<Params>(params)...);
 	}
+
 	template<typename T> using WorkPtrT = std::shared_ptr<WorkItemT<T>>;
 
 private:
diff --git a/test/enumDetailsData.h b/test/enumDetailsData.h
index 713d742..b7bd601 100644
--- a/test/enumDetailsData.h
+++ b/test/enumDetailsData.h
@@ -3,13 +3,16 @@
 
 enum GlobalUnscoped { aa, b, c };
 enum class GlobalScoped { aa, b, c };
+
 namespace ns {
 	enum Unscoped { aa, b, c };
 	enum class Scoped { aa, b, c };
 }
+
 namespace test1 {
 	enum class DefaultDense { a, bee, ci, de };
 }
+
 namespace test2 {
 	enum class NumberedSparse { a = 0, bee = 3, ci = -20, de = 100 };
 }
diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 18dc778..145481e 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -24,44 +24,52 @@ BOOST_GLOBAL_FIXTURE(ApplicationBase);
 BOOST_GLOBAL_FIXTURE(TestMainWindow);
 
 const std::filesystem::path TMP {"/tmp"};
+
 class FactoryFixture : public TestRenderOutputSize<glm::ivec2 {2048, 1024}>, public SceneProvider {
 public:
 	FactoryFixture() : sceneRenderer {size, output} { }
+
 	~FactoryFixture()
 	{
 		auto outpath = (TMP / boost::unit_test::framework::current_test_case().full_name()).replace_extension(".tga");
 		std::filesystem::create_directories(outpath.parent_path());
 		Texture::save(outImage, outpath.c_str());
 	}
+
 	void
 	content(const SceneShader & shader) const override
 	{
 		shader.basic.use(Location {{0, 0, 0}, {0, 0, 0}});
 		objects.apply(&Renderable::render, shader);
 	}
+
 	void
 	lights(const SceneShader & shader) const override
 	{
 		shader.pointLight.add({-3, 1, 5}, {1, 1, 1}, .1F);
 	}
+
 	void
 	environment(const SceneShader &, const SceneRenderer & sceneRenderer) const override
 	{
 		sceneRenderer.setAmbientLight({.4, .4, .4});
 		sceneRenderer.setDirectionalLight({.6, .6, .6}, east + south + south + down, *this);
 	}
+
 	void
 	shadows(const ShadowMapper & mapper) const override
 	{
 		mapper.dynamicPoint.use(Location {{0, 0, 0}, {0, 0, 0}});
 		objects.apply(&Renderable::shadows, mapper);
 	}
+
 	void
 	render(float dist = 10.f)
 	{
 		sceneRenderer.camera.setView({-dist, dist * 1.2f, dist * 1.2f}, south + east + down);
 		sceneRenderer.render(*this);
 	}
+
 	Collection<const Renderable> objects;
 
 private:
@@ -69,6 +77,7 @@ private:
 };
 
 BOOST_FIXTURE_TEST_SUITE(m, FactoryFixture);
+
 BOOST_AUTO_TEST_CASE(brush47xml, *boost::unit_test::timeout(5))
 {
 	auto mf = AssetFactory::loadXML(RESDIR "/brush47.xml");
@@ -115,6 +124,7 @@ BOOST_AUTO_TEST_CASE(foliage, *boost::unit_test::timeout(5))
 
 	render(5);
 }
+
 BOOST_AUTO_TEST_SUITE_END();
 
 BOOST_AUTO_TEST_CASE(loadall)
@@ -125,6 +135,7 @@ BOOST_AUTO_TEST_CASE(loadall)
 }
 
 template<typename T> using InOut = std::tuple<T, T>;
+
 BOOST_DATA_TEST_CASE(normalizeColourName,
 		boost::unit_test::data::make<InOut<std::string>>({
 				{"", ""},
diff --git a/test/test-collection.cpp b/test/test-collection.cpp
index 16db792..00204fc 100644
--- a/test/test-collection.cpp
+++ b/test/test-collection.cpp
@@ -13,12 +13,14 @@ public:
 	Base() = default;
 	virtual ~Base() = default;
 	DEFAULT_MOVE_COPY(Base);
+
 	virtual bool
 	add()
 	{
 		total += 1;
 		return false;
 	}
+
 	unsigned int total {0};
 };
 
diff --git a/test/test-geo.cpp b/test/test-geo.cpp
index e672e54..9874fb7 100644
--- a/test/test-geo.cpp
+++ b/test/test-geo.cpp
@@ -108,6 +108,7 @@ BOOST_AUTO_TEST_CASE(get_height_at)
 
 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,
@@ -145,6 +146,7 @@ BOOST_DATA_TEST_CASE(raytracer,
 
 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}},
@@ -169,6 +171,7 @@ BOOST_DATA_TEST_CASE(intersect_ray,
 	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);
 	}
@@ -178,6 +181,7 @@ auto xs = boost::unit_test::data::xrange(-20.F, 0.F, 0.6F), ys = boost::unit_tes
 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
@@ -189,8 +193,10 @@ BOOST_DATA_TEST_CASE(intersect_ray_many, xs * ys * targetsx * targetsy, x, y, ta
 	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);
 		}
@@ -198,6 +204,7 @@ BOOST_DATA_TEST_CASE(intersect_ray_many, xs * ys * targetsx * targetsy, x, y, ta
 }
 
 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}},
diff --git a/test/test-glContainer.cpp b/test/test-glContainer.cpp
index 33ec992..cd57a6b 100644
--- a/test/test-glContainer.cpp
+++ b/test/test-glContainer.cpp
@@ -281,6 +281,7 @@ struct C {
 	int x;
 	float y;
 };
+
 static_assert(std::is_trivially_destructible_v<C>);
 
 BOOST_FIXTURE_TEST_SUITE(c, glContainer<C>)
@@ -307,9 +308,11 @@ struct CC {
 	{
 		++x;
 	}
+
 	int x;
 	float y;
 };
+
 static_assert(!std::is_trivially_destructible_v<CC>);
 
 BOOST_FIXTURE_TEST_SUITE(cc, glContainer<CC>)
diff --git a/test/test-glContextBhvr.cpp b/test/test-glContextBhvr.cpp
index 769f61f..26b45d9 100644
--- a/test/test-glContextBhvr.cpp
+++ b/test/test-glContextBhvr.cpp
@@ -11,12 +11,14 @@
 BOOST_GLOBAL_FIXTURE(ApplicationBase);
 
 #define TEST_WINDOW_PARAMS __FILE__, 0, 0, 640, 480, static_cast<Uint32>(SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN)
+
 static void
 CreateProgramTest()
 {
 	const ProgramRef p;
 	BOOST_REQUIRE(p);
 }
+
 BOOST_AUTO_TEST_CASE(windowContextThingsBehaviour1)
 {
 	BOOST_REQUIRE(!glCreateProgram); // Init not called yet
diff --git a/test/test-instancing.cpp b/test/test-instancing.cpp
index 7d8ea55..c1860a4 100644
--- a/test/test-instancing.cpp
+++ b/test/test-instancing.cpp
@@ -163,6 +163,7 @@ BOOST_DATA_TEST_CASE(shuffle_random, boost::unit_test::data::xrange(0, 10), x)
 				iused.emplace(index[i]);
 			}
 		}
+
 		BOOST_TEST_CONTEXT(index) {
 			BOOST_REQUIRE_EQUAL(iused.size(), size());
 			if (!iused.empty()) {
diff --git a/test/test-lib.cpp b/test/test-lib.cpp
index aaf6292..58b769a 100644
--- a/test/test-lib.cpp
+++ b/test/test-lib.cpp
@@ -9,6 +9,7 @@
 #include <set>
 
 std::set<GLuint> active;
+
 void
 generator(GLsizei n, GLuint * out)
 {
diff --git a/test/test-maths.cpp b/test/test-maths.cpp
index a4a881d..2560319 100644
--- a/test/test-maths.cpp
+++ b/test/test-maths.cpp
@@ -36,6 +36,7 @@ static_assert(east.x > 0);
 static_assert(west == -east);
 // (-ve, y, z) is "west"
 static_assert(west.x < 0);
+
 //
 // Therefore, the geographic world exists west -ve to east +ve and from south -ve to north +ve.  Forward shall be
 // considered +ve motion; the "front" of a vehicle shall have a +ve value in y axis.
@@ -110,9 +111,11 @@ const auto rots = boost::unit_test::data::make<std::tuple<glm::vec3, glm::mat4 (
 		{east, rotate_pitch, "pitch"},
 		{north, rotate_roll, "roll"},
 });
+
 BOOST_DATA_TEST_CASE(test_rotations, (angs + random_angs) * rots, angle, ai, axis, ilt_func, name)
 {
 	(void)ai;
+
 	BOOST_TEST_CONTEXT(name) {
 		const auto g {glm::rotate(angle, axis)}, ilt {ilt_func(angle)};
 		for (glm::length_t c = 0; c < 4; c++) {
@@ -130,6 +133,7 @@ BOOST_DATA_TEST_CASE(test_rotations, (angs + random_angs) * rots, angle, ai, axi
 // An arc shall be defined as a centre point, start point and end point. The arc shall progress positively from start to
 // end in a clockwise manner. Arc start shall be the yaw from centre to start, arc end shall be greater than arc start.
 using pos3_to_arc = std::tuple<glm::vec3, glm::vec3, glm::vec3, Arc>;
+
 BOOST_DATA_TEST_CASE(test_create_arc,
 		boost::unit_test::data::make<pos3_to_arc>({
 				{{0, 0, 0}, north, east, {0, half_pi}},
@@ -148,6 +152,7 @@ BOOST_DATA_TEST_CASE(test_create_arc,
 }
 
 using fac = std::tuple<glm::vec2, float, glm::vec2, float, glm::vec2, bool>;
+
 BOOST_DATA_TEST_CASE(test_find_arc_centre,
 		boost::unit_test::data::make<fac>({
 				{{2, 2}, pi, {3, 3}, half_pi, {3, 2}, true},
@@ -178,6 +183,7 @@ struct TestLinkStraight : public LinkStraight {
 };
 
 using StraightsData = std::tuple<glm::vec3, float /*angFor*/, float /* angBack*/>;
+
 BOOST_DATA_TEST_CASE(straight1,
 		boost::unit_test::data::make<StraightsData>({
 				{north, 0, pi},
@@ -210,6 +216,7 @@ struct TestLinkCurve : public LinkCurve {
 };
 
 using CurvesData = std::tuple<glm::vec3 /*e1*/, glm::vec3 /*ctr*/, float /*angFor*/, float /* angBack*/>;
+
 BOOST_DATA_TEST_CASE(curve1,
 		boost::unit_test::data::make<CurvesData>({
 				{north + east, east, 0, -half_pi},
diff --git a/test/test-network.cpp b/test/test-network.cpp
index a8db2b6..ab0818a 100644
--- a/test/test-network.cpp
+++ b/test/test-network.cpp
@@ -25,8 +25,11 @@ BOOST_GLOBAL_FIXTURE(TestMainWindow);
 
 struct TestLink : public LinkStraight {
 	TestLink(const Node::Ptr & a, const Node::Ptr & b) : TestLink {a, b, (a->pos - b->pos)} { }
+
 	TestLink(Node::Ptr a, Node::Ptr b, glm::vec2 l) : Link {{std::move(a), 0}, {std::move(b), pi}, glm::length(l)} { }
+
 	TestLink(Node::Ptr a, Node::Ptr b, float l) : Link {{std::move(a), 0}, {std::move(b), pi}, l} { }
+
 	using StraightLink = TestLink;
 	using CurveLink = TestLink;
 };
diff --git a/test/test-persistence.cpp b/test/test-persistence.cpp
index 38bbf2f..abb68c2 100644
--- a/test/test-persistence.cpp
+++ b/test/test-persistence.cpp
@@ -26,6 +26,7 @@ struct JPP {
 			BOOST_REQUIRE(to);
 			return to;
 		}
+
 		// Presumably BOOST_TEST_CONTEXT is implemented as an if (...) { }
 		throw std::logic_error("We shouldn't ever get here, but apparently we can!");
 	}
@@ -213,6 +214,7 @@ auto const TEST_STRINGS_DECODE_ONLY = boost::unit_test::data::make<svs>({
 		{R"J("\u056b ARMENIAN SMALL LETTER INI")J", "ի ARMENIAN SMALL LETTER INI"},
 		{R"J("\u0833 SAMARITAN PUNCTUATION BAU")J", "࠳ SAMARITAN PUNCTUATION BAU"},
 });
+
 BOOST_DATA_TEST_CASE(load_strings, TEST_STRINGS + TEST_STRINGS_DECODE_ONLY, in, exp)
 {
 	std::stringstream str {in};
@@ -220,6 +222,7 @@ BOOST_DATA_TEST_CASE(load_strings, TEST_STRINGS + TEST_STRINGS_DECODE_ONLY, in,
 }
 
 using cpstr = std::tuple<unsigned long, std::string_view>;
+
 BOOST_DATA_TEST_CASE(utf8_decode,
 		boost::unit_test::data::make<cpstr>({
 				{9, "\t"},
@@ -296,6 +299,7 @@ BOOST_AUTO_TEST_CASE(get_default_id)
 {
 	SubObject2 so;
 	const auto id {so.getId()};
+
 	BOOST_TEST_CONTEXT(id) {
 		auto ptr = std::stoul(id, nullptr, 16);
 		BOOST_CHECK_EQUAL(ptr, reinterpret_cast<decltype(ptr)>(&so));
diff --git a/test/test-render.cpp b/test/test-render.cpp
index 0d384a3..b16f241 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -43,16 +43,19 @@ public:
 		train2->bogies.front().setPosition(train2->bogies.front().position() + train2->location.position());
 		train2->bogies.back().setPosition(train2->bogies.back().position() + train2->location.position());
 	}
+
 	void
 	content(const SceneShader & shader) const override
 	{
 		terrain.render(shader);
 		brush47rvc->render(shader);
 	}
+
 	void
 	lights(const SceneShader &) const override
 	{
 	}
+
 	void
 	shadows(const ShadowMapper & shadowMapper) const override
 	{
@@ -95,6 +98,7 @@ BOOST_AUTO_TEST_CASE(pointlight)
 {
 	SceneRenderer ss {size, output};
 	ss.camera.setView({-10, -10, 60}, glm::normalize(glm::vec3 {1, 1, -0.5F}));
+
 	class PointLightScene : public TestScene {
 	public:
 		void
@@ -103,6 +107,7 @@ BOOST_AUTO_TEST_CASE(pointlight)
 			r.setAmbientLight({0.2F, 0.2F, 0.2F});
 			r.setDirectionalLight({0.2F, 0.2F, 0.2F}, west + down, *this);
 		}
+
 		void
 		lights(const SceneShader & shader) const override
 		{
@@ -113,6 +118,7 @@ BOOST_AUTO_TEST_CASE(pointlight)
 			}
 		}
 	};
+
 	const PointLightScene scene;
 	ss.render(scene);
 	Texture::save(outImage, "/tmp/pointlight.tga");
@@ -122,6 +128,7 @@ BOOST_AUTO_TEST_CASE(spotlight)
 {
 	SceneRenderer ss {size, output};
 	ss.camera.setView({-10, -10, 60}, glm::normalize(glm::vec3 {1, 1, -0.5F}));
+
 	class PointLightScene : public TestScene {
 	public:
 		void
@@ -130,6 +137,7 @@ BOOST_AUTO_TEST_CASE(spotlight)
 			r.setAmbientLight({0.2F, 0.2F, 0.2F});
 			r.setDirectionalLight({0.2F, 0.2F, 0.2F}, west + down, *this);
 		}
+
 		void
 		lights(const SceneShader & shader) const override
 		{
@@ -139,6 +147,7 @@ BOOST_AUTO_TEST_CASE(spotlight)
 			shader.spotLight.add({60, 50, 3}, north + east, {1.0, 1.0, 1.0}, 0.0001F, .7F);
 		}
 	};
+
 	const PointLightScene scene;
 	ss.render(scene);
 	Texture::save(outImage, "/tmp/spotlight.tga");
diff --git a/test/test-text.cpp b/test/test-text.cpp
index 629892f..166a6fa 100644
--- a/test/test-text.cpp
+++ b/test/test-text.cpp
@@ -36,6 +36,7 @@ struct FontTest : public Font {
 BOOST_TEST_DONT_PRINT_LOG_VALUE(Font::CharData);
 
 using TextureSizeTestData = std::tuple<unsigned, unsigned, unsigned>;
+
 BOOST_DATA_TEST_CASE(fontTextureSize, boost::unit_test::data::make<unsigned>({2, 3, 10, 50, 250}), fontHeight)
 {
 	auto isPowerOfTwo = [](auto x) {
@@ -64,6 +65,7 @@ BOOST_AUTO_TEST_CASE(initialize_chardata)
 }
 
 using CharDataTest = std::tuple<decltype(get_codepoint(nullptr)), Font::CharData>;
+
 BOOST_DATA_TEST_CASE(initialize_chardata_A,
 		boost::unit_test::data::make<CharDataTest>({
 				{'A', {0, {34, 35}, {627, 0}, {-1, 35}, 32}},
diff --git a/test/testMainWindow.h b/test/testMainWindow.h
index bc9c0bd..445491d 100644
--- a/test/testMainWindow.h
+++ b/test/testMainWindow.h
@@ -7,6 +7,7 @@ class TestMainWindow : public Window {
 	// in the same way a real main window would always exist.
 public:
 	TestMainWindow();
+
 	void
 	tick(TickDuration) override
 	{
diff --git a/test/testRenderOutput.h b/test/testRenderOutput.h
index f5cd56b..13c380f 100644
--- a/test/testRenderOutput.h
+++ b/test/testRenderOutput.h
@@ -17,6 +17,7 @@ public:
 	glRenderBuffer depth;
 	glTexture outImage;
 };
+
 template<glm::ivec2 Size> class TestRenderOutputSize : public TestRenderOutput {
 public:
 	TestRenderOutputSize() : TestRenderOutput {Size} { }
diff --git a/ui/font.cpp b/ui/font.cpp
index 108f905..ebd856d 100644
--- a/ui/font.cpp
+++ b/ui/font.cpp
@@ -14,6 +14,7 @@
 #include <unicode.h>
 #include <util.h>
 #include <utility>
+
 // IWYU pragma: no_forward_declare FT_LibraryRec_
 
 std::string
diff --git a/ui/font.h b/ui/font.h
index 6c86e18..2f3337f 100644
--- a/ui/font.h
+++ b/ui/font.h
@@ -31,6 +31,7 @@ public:
 		glm::ivec2 bearing;
 		long advance;
 	};
+
 	struct FontTexture {
 		glTexture texture;
 		unsigned int used;
diff --git a/ui/gameMainSelector.cpp b/ui/gameMainSelector.cpp
index 081718d..6c6935c 100644
--- a/ui/gameMainSelector.cpp
+++ b/ui/gameMainSelector.cpp
@@ -15,6 +15,7 @@
 #include <vector>
 
 GameMainSelector::GameMainSelector(const Camera * c, glm::vec2 size) : UIComponent {{{}, size}}, camera {c} { }
+
 constexpr glm::vec2 TargetPos {5, 45};
 
 void
diff --git a/ui/gameMainWindow.cpp b/ui/gameMainWindow.cpp
index c35c9c6..b94accd 100644
--- a/ui/gameMainWindow.cpp
+++ b/ui/gameMainWindow.cpp
@@ -48,6 +48,7 @@ GameMainWindow::render() const
 	SceneRenderer::render(*this);
 	Window::render();
 }
+
 void
 GameMainWindow::content(const SceneShader & shader) const
 {
@@ -59,17 +60,20 @@ GameMainWindow::content(const SceneShader & shader) const
 	gameState->world.apply<Renderable>(&Renderable::render, shader);
 	uiComponents.apply<WorldOverlay>(&WorldOverlay::render, shader);
 }
+
 void
 GameMainWindow::environment(const SceneShader & s, const SceneRenderer & r) const
 {
 	// default for now
 	SceneProvider::environment(s, r);
 }
+
 void
 GameMainWindow::lights(const SceneShader & shader) const
 {
 	gameState->world.apply<Renderable>(&Renderable::lights, shader);
 }
+
 void
 GameMainWindow::shadows(const ShadowMapper & shadowMapper) const
 {
diff --git a/ui/iconButton.h b/ui/iconButton.h
index 6ac9317..0afe92d 100644
--- a/ui/iconButton.h
+++ b/ui/iconButton.h
@@ -10,6 +10,7 @@ class UIShader;
 union SDL_Event;
 
 static const constexpr glm::vec2 ICON_SIZE {32.F, 32.F};
+
 class IconButton : public UIComponent {
 public:
 	IconButton(const std::string & icon, glm::vec2 position, UIEvent click);
diff --git a/ui/modeHelper.h b/ui/modeHelper.h
index 77707f2..d20f2db 100644
--- a/ui/modeHelper.h
+++ b/ui/modeHelper.h
@@ -4,6 +4,7 @@
 union SDL_Event;
 
 enum ModeSecondClick { Unset, Reset, NoAction };
+
 template<typename Target, ModeSecondClick msc = ModeSecondClick::Unset> class Mode {
 public:
 	explicit Mode(Target & t) : target {t} { }
diff --git a/ui/text.cpp b/ui/text.cpp
index d24c268..b776b90 100644
--- a/ui/text.cpp
+++ b/ui/text.cpp
@@ -12,6 +12,7 @@
 #include <utility>
 
 const std::filesystem::path font {"/usr/share/fonts/hack/Hack-Regular.ttf"};
+
 Text::Text(std::string_view s, Position pos, glm::vec3 c) : UIComponent {pos}, colour {c}
 {
 	for (const auto & textureQuads :
diff --git a/ui/text.h b/ui/text.h
index 9fe87d1..de2fe2e 100644
--- a/ui/text.h
+++ b/ui/text.h
@@ -25,6 +25,7 @@ private:
 		glVertexArray vao;
 		glBuffer vbo;
 	};
+
 	std::vector<Model> models;
 	glm::vec3 colour;
 };
diff --git a/ui/uiComponent.cpp b/ui/uiComponent.cpp
index e480fbc..aa4838d 100644
--- a/ui/uiComponent.cpp
+++ b/ui/uiComponent.cpp
@@ -20,6 +20,7 @@ UIComponent::Position::operator&(const glm::vec2 & pos) const
 {
 	return (pos.x >= origin.x && pos.y >= origin.y && pos.x < origin.x + size.x && pos.y < origin.y + size.y);
 }
+
 bool
 UIComponent::Position::operator&(const SDL_MouseButtonEvent & pos) const
 {
diff --git a/ui/uiComponent.h b/ui/uiComponent.h
index 75c2284..71d2659 100644
--- a/ui/uiComponent.h
+++ b/ui/uiComponent.h
@@ -18,6 +18,7 @@ public:
 		bool operator&(const SDL_MouseButtonEvent &) const;
 		bool operator&(const glm::vec2 &) const;
 	};
+
 	explicit UIComponent(Position);
 	virtual ~UIComponent() = default;
 
diff --git a/ui/uiComponentPlacer.cpp b/ui/uiComponentPlacer.cpp
index 368e772..5e645d8 100644
--- a/ui/uiComponentPlacer.cpp
+++ b/ui/uiComponentPlacer.cpp
@@ -16,6 +16,7 @@ UIComponentPlacer::next(glm::vec2 size)
 	max = std::max(max, size[1 - axis]);
 	return n;
 }
+
 glm::vec2
 UIComponentPlacer::getLimit() const
 {
diff --git a/ui/window.h b/ui/window.h
index 369228a..183a65a 100644
--- a/ui/window.h
+++ b/ui/window.h
@@ -31,6 +31,7 @@ public:
 
 protected:
 	virtual void render() const;
+
 	struct GLInitHelper {
 		GLInitHelper();
 	};
-- 
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

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(-)

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(-)

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 b44d10c03299953104266f01f6415b945e6520b9 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Thu, 9 Nov 2023 17:38:39 +0000
Subject: Fix definition of shadowMapRegions

---
 gfx/gl/shadowMapper.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 94a0791..e4ee47a 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -57,7 +57,7 @@ constexpr std::array<std::array<TextureAbsRegion, ShadowMapper::SHADOW_BANDS>, S
 				{1, 1, 1, 1}, // upper right
 		}},
 }};
-constexpr std::array<std::array<TextureAbsRegion, ShadowMapper::SHADOW_BANDS>, ShadowMapper::SHADOW_BANDS>
+constexpr std::array<std::array<TextureRelRegion, ShadowMapper::SHADOW_BANDS>, ShadowMapper::SHADOW_BANDS>
 		shadowMapRegions {{
 				{{
 						{0.5F, 0.5F, 0.5F, 0.5F}, // full
-- 
cgit v1.2.3


From 5bc0462311ab4c691102f0bc39d6ae03c61a287b Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 11 Nov 2023 17:32:05 +0000
Subject: Add Location method for getting the rotation only transform

---
 lib/location.cpp | 6 ++++++
 lib/location.h   | 1 +
 2 files changed, 7 insertions(+)

diff --git a/lib/location.cpp b/lib/location.cpp
index 732dd6d..9a31402 100644
--- a/lib/location.cpp
+++ b/lib/location.cpp
@@ -7,3 +7,9 @@ Location::getTransform() const
 {
 	return glm::translate(pos) * rotate_ypr(rot);
 }
+
+glm::mat4
+Location::getRotationTransform() const
+{
+	return rotate_ypr(rot);
+}
diff --git a/lib/location.h b/lib/location.h
index 7f2b44d..55737ae 100644
--- a/lib/location.h
+++ b/lib/location.h
@@ -10,6 +10,7 @@ public:
 #endif
 
 	[[nodiscard]] glm::mat4 getTransform() const;
+	[[nodiscard]] glm::mat4 getRotationTransform() const;
 
 	Position3D pos;
 	Rotation3D rot;
-- 
cgit v1.2.3


From ba4bca84808bebfc81be7df2cb536d1f73451bc6 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 11 Nov 2023 17:35:07 +0000
Subject: Add BufferedLocation method for getting the rotation only transform

---
 gfx/gl/bufferedLocation.cpp | 6 ++++++
 gfx/gl/bufferedLocation.h   | 1 +
 2 files changed, 7 insertions(+)

diff --git a/gfx/gl/bufferedLocation.cpp b/gfx/gl/bufferedLocation.cpp
index 62cadef..6ba8812 100644
--- a/gfx/gl/bufferedLocation.cpp
+++ b/gfx/gl/bufferedLocation.cpp
@@ -63,3 +63,9 @@ BufferedLocation::getTransform() const
 {
 	return loc.getTransform();
 }
+
+glm::mat4
+BufferedLocation::getRotationTransform() const
+{
+	return loc.getRotationTransform();
+}
diff --git a/gfx/gl/bufferedLocation.h b/gfx/gl/bufferedLocation.h
index 39d3139..8302b3c 100644
--- a/gfx/gl/bufferedLocation.h
+++ b/gfx/gl/bufferedLocation.h
@@ -23,6 +23,7 @@ public:
 	void setLocation(Position3D, Rotation3D);
 
 	[[nodiscard]] glm::mat4 getTransform() const;
+	[[nodiscard]] glm::mat4 getRotationTransform() const;
 
 private:
 	virtual void updateBuffer() = 0;
-- 
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(-)

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(-)

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(-)

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 9bbaa4df842bf350a5d05233140bb4d631212a11 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 25 Nov 2023 13:57:33 +0000
Subject: Send position and rotation matrix to GPU separately in basic program

Missed from earlier commit
---
 gfx/gl/sceneShader.cpp | 9 ++++++---
 gfx/gl/sceneShader.h   | 1 +
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/gfx/gl/sceneShader.cpp b/gfx/gl/sceneShader.cpp
index 2f391fd..de75814 100644
--- a/gfx/gl/sceneShader.cpp
+++ b/gfx/gl/sceneShader.cpp
@@ -60,13 +60,16 @@ SceneShader::SceneProgram::setViewPort(const ViewPort & viewPort) const
 	}
 }
 
-SceneShader::BasicProgram::BasicProgram() : SceneProgram {dynamicPoint_vs, material_fs}, modelLoc {*this, "model"} { }
+SceneShader::BasicProgram::BasicProgram() :
+	SceneProgram {dynamicPoint_vs, material_fs}, modelLoc {*this, "model"}, modelPosLoc {*this, "modelPos"}
+{
+}
 
 void
 SceneShader::BasicProgram::setModel(Location const & location) const
 {
-	const auto model {glm::translate(location.pos) * rotate_ypr(location.rot)};
-	glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
+	glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(rotate_ypr(location.rot)));
+	glUniform3fv(modelPosLoc, 1, glm::value_ptr(location.pos));
 }
 
 void
diff --git a/gfx/gl/sceneShader.h b/gfx/gl/sceneShader.h
index 154dc17..83c234c 100644
--- a/gfx/gl/sceneShader.h
+++ b/gfx/gl/sceneShader.h
@@ -32,6 +32,7 @@ class SceneShader {
 
 	private:
 		RequiredUniformLocation modelLoc;
+		RequiredUniformLocation modelPosLoc;
 	};
 
 	class AbsolutePosProgram : public SceneProgram {
-- 
cgit v1.2.3


From 4c4328d6091ff467fd590c1cc1dc9435c920f6a7 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 25 Nov 2023 14:08:02 +0000
Subject: Spread the trees out

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

diff --git a/application/main.cpp b/application/main.cpp
index 01e6561..e4e71c7 100644
--- a/application/main.cpp
+++ b/application/main.cpp
@@ -80,8 +80,8 @@ public:
 			train->currentActivity = train->orders.current()->createActivity();
 
 			auto foliage = std::dynamic_pointer_cast<Foliage>(assets.at("Tree-01-1"));
-			for (float x = 900000; x < 1100000; x += 3000) {
-				for (float y = 900000; y < 1100000; y += 3000) {
+			for (float x = 900000; x < 1100000; x += 5000) {
+				for (float y = 900000; y < 1100000; y += 5000) {
 					world.create<Plant>(foliage, Location {geoData->positionAt({-x, -y})});
 				}
 			}
-- 
cgit v1.2.3


From 916fafa028b0bc8c8b0abec8c072722907d85f43 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 25 Nov 2023 14:08:45 +0000
Subject: Send position and rotation matrix to GPU separately in shadowmapper
 dynamic

---
 gfx/gl/shadowMapper.cpp | 9 ++++-----
 gfx/gl/shadowMapper.h   | 1 +
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 190f20e..4a8d7ec 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -179,7 +179,8 @@ ShadowMapper::FixedPoint::use() const
 }
 
 ShadowMapper::DynamicPoint::DynamicPoint() :
-	Program {shadowDynamicPoint_vs}, viewProjectionLoc {*this, "viewProjection"}, modelLoc {*this, "model"}
+	Program {shadowDynamicPoint_vs}, viewProjectionLoc {*this, "viewProjection"}, modelLoc {*this, "model"},
+	modelPosLoc {*this, "modelPos"}
 {
 }
 
@@ -195,13 +196,11 @@ ShadowMapper::DynamicPoint::use(const Location & location) const
 {
 	glUseProgram(*this);
 	setModel(location);
-	const auto model = glm::translate(location.pos) * rotate_ypr(location.rot);
-	glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
 }
 
 void
 ShadowMapper::DynamicPoint::setModel(const Location & location) const
 {
-	const auto model = glm::translate(location.pos) * rotate_ypr(location.rot);
-	glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
+	glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(rotate_ypr(location.rot)));
+	glUniform3fv(modelPosLoc, 1, glm::value_ptr(location.pos));
 }
diff --git a/gfx/gl/shadowMapper.h b/gfx/gl/shadowMapper.h
index d54734c..b53a7f1 100644
--- a/gfx/gl/shadowMapper.h
+++ b/gfx/gl/shadowMapper.h
@@ -44,6 +44,7 @@ public:
 	private:
 		RequiredUniformLocation viewProjectionLoc;
 		RequiredUniformLocation modelLoc;
+		RequiredUniformLocation modelPosLoc;
 	};
 
 	FixedPoint fixedPoint, dynamicPointInst;
-- 
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(-)

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(-)

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