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 +
 1 file changed, 1 insertion(+)

(limited to 'application')

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()
 	{
-- 
cgit v1.2.3


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

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

(limited to 'application')

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

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

(limited to 'application')

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

(limited to 'application')

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