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

---
 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 ++++++------
 13 files changed, 51 insertions(+), 44 deletions(-)

(limited to 'gfx')

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 {};
 };
-- 
cgit v1.2.3


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

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

(limited to 'gfx')

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


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

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

(limited to 'gfx')

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

(limited to 'gfx')

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

(limited to 'gfx')

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

(limited to 'gfx')

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


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

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

(limited to 'gfx')

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


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

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

(limited to 'gfx')

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

(limited to 'gfx')

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

(limited to 'gfx')

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

(limited to 'gfx')

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


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

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

(limited to 'gfx')

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


From 4e6f8db35ddc8fd3f310bb5616d257b5f9996d94 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 3 Dec 2023 12:37:46 +0000
Subject: Shader viewPoint now an integer

---
 gfx/gl/sceneShader.cpp                   | 6 +++---
 gfx/gl/sceneShader.h                     | 4 ++--
 gfx/gl/shaders/dynamicPoint.vs           | 2 +-
 gfx/gl/shaders/dynamicPointInst.vs       | 2 +-
 gfx/gl/shaders/fixedPoint.vs             | 2 +-
 gfx/gl/shaders/pointLight.gs             | 2 +-
 gfx/gl/shaders/pointLight.vs             | 2 +-
 gfx/gl/shaders/shadowDynamicPoint.vs     | 2 +-
 gfx/gl/shaders/shadowDynamicPointInst.vs | 2 +-
 gfx/gl/shaders/shadowFixedPoint.vs       | 2 +-
 gfx/gl/shaders/spotLight.gs              | 2 +-
 gfx/gl/shaders/spotLight.vs              | 2 +-
 gfx/gl/shaders/water.vs                  | 2 +-
 13 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/sceneShader.cpp b/gfx/gl/sceneShader.cpp
index 59a9748..57c8bb7 100644
--- a/gfx/gl/sceneShader.cpp
+++ b/gfx/gl/sceneShader.cpp
@@ -26,7 +26,7 @@ SceneShader::SceneShader() :
 }
 
 void
-SceneShader::setViewProjection(const Position3D & viewPoint, const glm::mat4 & viewProjection) const
+SceneShader::setViewProjection(const GlobalPosition3D & viewPoint, const glm::mat4 & viewProjection) const
 {
 	for (const auto & prog : std::array<const SceneProgram *, 7> {
 				 &basic, &basicInst, &water, &landmass, &absolute, &pointLight, &spotLight}) {
@@ -44,11 +44,11 @@ SceneShader::setViewPort(const ViewPort & viewPort) const
 }
 
 void
-SceneShader::SceneProgram::setViewProjection(const Position3D & viewPoint, const glm::mat4 & viewProjection) const
+SceneShader::SceneProgram::setViewProjection(const GlobalPosition3D & viewPoint, const glm::mat4 & viewProjection) const
 {
 	glUseProgram(*this);
 	glUniformMatrix4fv(viewProjectionLoc, 1, GL_FALSE, glm::value_ptr(viewProjection));
-	glUniform3fv(viewPointLoc, 1, glm::value_ptr(viewPoint));
+	glUniform3iv(viewPointLoc, 1, glm::value_ptr(viewPoint));
 }
 
 void
diff --git a/gfx/gl/sceneShader.h b/gfx/gl/sceneShader.h
index 83c234c..7ffaacd 100644
--- a/gfx/gl/sceneShader.h
+++ b/gfx/gl/sceneShader.h
@@ -16,7 +16,7 @@ class SceneShader {
 		{
 		}
 
-		void setViewProjection(const Position3D &, const glm::mat4 &) const;
+		void setViewProjection(const GlobalPosition3D &, const glm::mat4 &) const;
 		void setViewPort(const ViewPort &) const;
 
 	private:
@@ -91,6 +91,6 @@ public:
 	PointLightShader pointLight;
 	SpotLightShader spotLight;
 
-	void setViewProjection(const Position3D & viewPoint, const glm::mat4 & viewProjection) const;
+	void setViewProjection(const GlobalPosition3D & viewPoint, const glm::mat4 & viewProjection) const;
 	void setViewPort(const ViewPort & viewPort) const;
 };
diff --git a/gfx/gl/shaders/dynamicPoint.vs b/gfx/gl/shaders/dynamicPoint.vs
index 667f247..097cd11 100644
--- a/gfx/gl/shaders/dynamicPoint.vs
+++ b/gfx/gl/shaders/dynamicPoint.vs
@@ -5,7 +5,7 @@ include(`meshIn.glsl')
 include(`materialInterface.glsl')
 
 uniform mat4 viewProjection;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 uniform mat4 model;
 uniform ivec3 modelPos;
 
diff --git a/gfx/gl/shaders/dynamicPointInst.vs b/gfx/gl/shaders/dynamicPointInst.vs
index adf39bd..529fe1d 100644
--- a/gfx/gl/shaders/dynamicPointInst.vs
+++ b/gfx/gl/shaders/dynamicPointInst.vs
@@ -5,7 +5,7 @@ include(`meshIn.glsl')
 include(`materialInterface.glsl')
 
 uniform mat4 viewProjection;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 layout(location = 5) in mat4 model;
 layout(location = 9) in ivec3 modelPos;
 
diff --git a/gfx/gl/shaders/fixedPoint.vs b/gfx/gl/shaders/fixedPoint.vs
index 6e1ab49..3cea737 100644
--- a/gfx/gl/shaders/fixedPoint.vs
+++ b/gfx/gl/shaders/fixedPoint.vs
@@ -5,7 +5,7 @@ include(`meshIn.glsl')
 include(`materialInterface.glsl')
 
 uniform mat4 viewProjection;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 const mat4 model = mat4(1);
 const vec3 modelPos = ivec3(0);
 
diff --git a/gfx/gl/shaders/pointLight.gs b/gfx/gl/shaders/pointLight.gs
index ec089f5..9c41ed4 100644
--- a/gfx/gl/shaders/pointLight.gs
+++ b/gfx/gl/shaders/pointLight.gs
@@ -19,7 +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;
+uniform ivec3 viewPoint;
 
 in vec3 centre[];
 in float size[];
diff --git a/gfx/gl/shaders/pointLight.vs b/gfx/gl/shaders/pointLight.vs
index 7694a25..00a34a3 100644
--- a/gfx/gl/shaders/pointLight.vs
+++ b/gfx/gl/shaders/pointLight.vs
@@ -4,7 +4,7 @@ layout(location = 0) in vec3 position;
 
 uniform vec3 colour;
 uniform float kq;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 
 out vec3 centre;
 out float size;
diff --git a/gfx/gl/shaders/shadowDynamicPoint.vs b/gfx/gl/shaders/shadowDynamicPoint.vs
index e20d31a..f21b3b6 100644
--- a/gfx/gl/shaders/shadowDynamicPoint.vs
+++ b/gfx/gl/shaders/shadowDynamicPoint.vs
@@ -3,7 +3,7 @@
 include(`meshIn.glsl')
 
 uniform mat4 viewProjection;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 uniform mat4 model;
 uniform ivec3 modelPos;
 
diff --git a/gfx/gl/shaders/shadowDynamicPointInst.vs b/gfx/gl/shaders/shadowDynamicPointInst.vs
index ab3e976..28a62d9 100644
--- a/gfx/gl/shaders/shadowDynamicPointInst.vs
+++ b/gfx/gl/shaders/shadowDynamicPointInst.vs
@@ -3,7 +3,7 @@
 include(`meshIn.glsl')
 
 uniform mat4 viewProjection;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 layout(location = 5) in mat4 model;
 layout(location = 9) in ivec3 modelPos;
 
diff --git a/gfx/gl/shaders/shadowFixedPoint.vs b/gfx/gl/shaders/shadowFixedPoint.vs
index a9fb4a3..168d5f1 100644
--- a/gfx/gl/shaders/shadowFixedPoint.vs
+++ b/gfx/gl/shaders/shadowFixedPoint.vs
@@ -3,7 +3,7 @@
 include(`meshIn.glsl')
 
 uniform mat4 viewProjection;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 const mat4 model = mat4(1);
 const ivec3 modelPos = ivec3(0);
 
diff --git a/gfx/gl/shaders/spotLight.gs b/gfx/gl/shaders/spotLight.gs
index 0529614..b58c169 100644
--- a/gfx/gl/shaders/spotLight.gs
+++ b/gfx/gl/shaders/spotLight.gs
@@ -10,7 +10,7 @@ const vec3[] pyramid = vec3[]( // four-sided
 		vec3(1, -1, 1) // Front-right
 );
 uniform mat4 viewProjection;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 uniform float arc;
 
 in vec3 position[];
diff --git a/gfx/gl/shaders/spotLight.vs b/gfx/gl/shaders/spotLight.vs
index 08197a4..ac1d1db 100644
--- a/gfx/gl/shaders/spotLight.vs
+++ b/gfx/gl/shaders/spotLight.vs
@@ -6,7 +6,7 @@ uniform vec3 v_direction;
 uniform vec3 colour;
 uniform float kq;
 uniform float arc;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 
 out vec3 position;
 out vec3 direction;
diff --git a/gfx/gl/shaders/water.vs b/gfx/gl/shaders/water.vs
index 03eabb2..f609d9e 100644
--- a/gfx/gl/shaders/water.vs
+++ b/gfx/gl/shaders/water.vs
@@ -4,7 +4,7 @@ include(`meshIn.glsl')
 include(`materialInterface.glsl')
 
 uniform mat4 viewProjection;
-uniform vec3 viewPoint;
+uniform ivec3 viewPoint;
 uniform vec3 waves;
 
 void
-- 
cgit v1.2.3


From 57d02ec977e04003aadbca8fc18ed0f4b98b3288 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 3 Dec 2023 14:22:06 +0000
Subject: Set the viewPoint uniform in shadow shaders

---
 gfx/gl/shadowMapper.cpp | 30 +++++++++++++++++++-----------
 gfx/gl/shadowMapper.h   |  8 ++++----
 2 files changed, 23 insertions(+), 15 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 07db6a1..66905df 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -131,12 +131,15 @@ ShadowMapper::update(const SceneProvider & scene, const Direction3D & dir, const
 	glCullFace(GL_FRONT);
 
 	const auto lightView = glm::lookAt(camera.getPosition(), camera.getPosition() + dir, up);
+	const auto lightViewDir = glm::lookAt(origin, dir, up);
+	const auto lightViewPoint = camera.getPosition();
 	const auto bandViewExtents = getBandViewExtents(camera, lightView);
 
 	Definitions out;
 	std::transform(bandViewExtents.begin(), std::prev(bandViewExtents.end()), std::next(bandViewExtents.begin()),
 			DefinitionsInserter {out},
-			[&scene, this, &lightView, bands = bandViewExtents.size() - 2, &out](const auto & near, const auto & far) {
+			[&scene, this, &lightView, bands = bandViewExtents.size() - 2, &out, &lightViewPoint, &lightViewDir](
+					const auto & near, const auto & far) {
 				const auto extents_minmax = [extents = std::span {near.begin(), far.end()}](auto && comp) {
 					const auto mm = std::minmax_element(extents.begin(), extents.end(), comp);
 					return std::make_pair(comp.get(*mm.first), comp.get(*mm.second));
@@ -146,16 +149,16 @@ ShadowMapper::update(const SceneProvider & scene, const Direction3D & dir, const
 					return glm::ortho(x.first, x.second, y.first, y.second, -z.second, -z.first);
 				}(extents_minmax(CompareBy {0}), extents_minmax(CompareBy {1}), extents_minmax(CompareBy {2}));
 
-				const auto lightViewProjection = lightProjection * lightView;
-				fixedPoint.setViewProjection(lightViewProjection);
-				dynamicPoint.setViewProjection(lightViewProjection);
-				dynamicPointInst.setViewProjection(lightViewProjection);
+				const auto lightViewDirProjection = lightProjection * lightViewDir;
+				fixedPoint.setViewProjection(lightViewPoint, lightViewDirProjection);
+				dynamicPoint.setViewProjection(lightViewPoint, lightViewDirProjection);
+				dynamicPointInst.setViewProjection(lightViewPoint, lightViewDirProjection);
 
 				const auto & viewport = viewports[bands][out.maps];
 				glViewport(size.x >> viewport.x, size.y >> viewport.y, size.x >> viewport.z, size.y >> viewport.w);
 				scene.shadows(*this);
 
-				return std::make_pair(lightViewProjection, shadowMapRegions[bands][out.maps]);
+				return std::make_pair(lightProjection * lightView, shadowMapRegions[bands][out.maps]);
 			});
 
 	glCullFace(GL_BACK);
@@ -163,13 +166,17 @@ ShadowMapper::update(const SceneProvider & scene, const Direction3D & dir, const
 	return out;
 }
 
-ShadowMapper::FixedPoint::FixedPoint(const Shader & vs) : Program {vs}, viewProjectionLoc {*this, "viewProjection"} { }
+ShadowMapper::FixedPoint::FixedPoint(const Shader & vs) :
+	Program {vs}, viewProjectionLoc {*this, "viewProjection"}, viewPointLoc {*this, "viewPoint"}
+{
+}
 
 void
-ShadowMapper::FixedPoint::setViewProjection(const glm::mat4 & viewProjection) const
+ShadowMapper::FixedPoint::setViewProjection(const GlobalPosition3D viewPoint, const glm::mat4 & viewProjection) const
 {
 	use();
 	glUniformMatrix4fv(viewProjectionLoc, 1, GL_FALSE, glm::value_ptr(viewProjection));
+	glUniform3iv(viewPointLoc, 1, glm::value_ptr(viewPoint));
 }
 
 void
@@ -179,16 +186,17 @@ ShadowMapper::FixedPoint::use() const
 }
 
 ShadowMapper::DynamicPoint::DynamicPoint() :
-	Program {shadowDynamicPoint_vs}, viewProjectionLoc {*this, "viewProjection"}, modelLoc {*this, "model"},
-	modelPosLoc {*this, "modelPos"}
+	Program {shadowDynamicPoint_vs}, viewProjectionLoc {*this, "viewProjection"}, viewPointLoc {*this, "viewPoint"},
+	modelLoc {*this, "model"}, modelPosLoc {*this, "modelPos"}
 {
 }
 
 void
-ShadowMapper::DynamicPoint::setViewProjection(const glm::mat4 & viewProjection) const
+ShadowMapper::DynamicPoint::setViewProjection(const GlobalPosition3D viewPoint, const glm::mat4 & viewProjection) const
 {
 	glUseProgram(*this);
 	glUniformMatrix4fv(viewProjectionLoc, 1, GL_FALSE, glm::value_ptr(viewProjection));
+	glUniform3iv(viewPointLoc, 1, glm::value_ptr(viewPoint));
 }
 
 void
diff --git a/gfx/gl/shadowMapper.h b/gfx/gl/shadowMapper.h
index b53a7f1..01520ca 100644
--- a/gfx/gl/shadowMapper.h
+++ b/gfx/gl/shadowMapper.h
@@ -27,22 +27,22 @@ public:
 	class FixedPoint : public Program {
 	public:
 		FixedPoint(const Shader & vs);
-		void setViewProjection(const glm::mat4 &) const;
+		void setViewProjection(const GlobalPosition3D, const glm::mat4 &) const;
 		void use() const;
 
 	private:
-		RequiredUniformLocation viewProjectionLoc;
+		RequiredUniformLocation viewProjectionLoc, viewPointLoc;
 	};
 
 	class DynamicPoint : public Program {
 	public:
 		DynamicPoint();
-		void setViewProjection(const glm::mat4 &) const;
+		void setViewProjection(const GlobalPosition3D, const glm::mat4 &) const;
 		void use(const Location &) const;
 		void setModel(const Location &) const;
 
 	private:
-		RequiredUniformLocation viewProjectionLoc;
+		RequiredUniformLocation viewProjectionLoc, viewPointLoc;
 		RequiredUniformLocation modelLoc;
 		RequiredUniformLocation modelPosLoc;
 	};
-- 
cgit v1.2.3


From daed922f23daa8a8e2659d8aea7864cccd5e08c7 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Mon, 11 Dec 2023 20:11:23 +0000
Subject: Integer camera

---
 gfx/gl/camera.cpp        | 36 ++++++++++++++++++------------------
 gfx/gl/camera.h          | 18 +++++++++---------
 gfx/gl/sceneRenderer.cpp |  2 +-
 gfx/gl/shadowMapper.cpp  | 16 ++++++++--------
 test/test-maths.cpp      |  2 +-
 test/test-render.cpp     | 14 +++++++-------
 6 files changed, 44 insertions(+), 44 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/camera.cpp b/gfx/gl/camera.cpp
index 15f76c4..a0d76ab 100644
--- a/gfx/gl/camera.cpp
+++ b/gfx/gl/camera.cpp
@@ -1,14 +1,14 @@
 #include "camera.h"
 #include <collections.h>
-#include <glm/gtx/intersect.hpp> // IWYU pragma: keep
-#include <glm/gtx/transform.hpp> // IWYU pragma: keep
-#include <math.h>
+#include <glm/gtx/transform.hpp>
 #include <maths.h>
 #include <ray.h>
 
-Camera::Camera(Position3D pos, Angle fov, Angle aspect, Distance zNear, Distance zFar) :
+Camera::Camera(GlobalPosition3D pos, Angle fov, Angle aspect, GlobalDistance zNear, GlobalDistance zFar) :
 	position {pos}, forward {::north}, up {::up}, near {zNear}, far {zFar},
-	projection {glm::perspective(fov, aspect, zNear, zFar)}, viewProjection {}, inverseViewProjection {}
+	projection {
+			glm::perspective(fov, aspect, static_cast<RelativeDistance>(zNear), static_cast<RelativeDistance>(zFar))},
+	viewProjection {}, inverseViewProjection {}
 {
 	updateView();
 }
@@ -25,7 +25,7 @@ void
 Camera::updateView()
 {
 	viewProjection = projection * glm::lookAt(origin, forward, up);
-	inverseViewProjection = glm::inverse(projection * glm::lookAt(position, position + forward, up));
+	inverseViewProjection = glm::inverse(viewProjection);
 }
 
 Direction3D
@@ -35,21 +35,21 @@ Camera::upFromForward(const Direction3D & forward)
 	return glm::cross(forward, right);
 }
 
-std::array<glm::vec4, 4>
-Camera::extentsAtDist(const float dist) const
+std::array<GlobalPosition4D, 4>
+Camera::extentsAtDist(const GlobalDistance dist) const
 {
-	const auto clampToSeaFloor = [this, dist](const Position3D & target) {
-		if (target.z < -1.5F) {
-			const auto vec = glm::normalize(target - position);
-			constexpr Position3D seafloor {0, 0, -1.5F};
-			float outdist {};
-			if (glm::intersectRayPlane(position, vec, seafloor, ::up, outdist)) {
-				return (vec * outdist + position) ^ outdist;
-			}
+	const auto clampToSeaFloor = [this, dist](GlobalPosition3D target) -> GlobalPosition4D {
+		target += position;
+		if (target.z < -1500) {
+			const auto diff = (target - position);
+			const auto something = (-1500 - position.z) / diff.z;
+			return {position + diff * something, dist};
 		}
-		return target ^ dist;
+		return {target, dist};
 	};
-	const auto depth = -(2.F * (dist - near) * far) / (dist * (near - far)) - 1.F;
+	const auto depth = -(2.F * (static_cast<float>(dist - near)) * static_cast<float>(far))
+					/ (static_cast<float>(dist) * (static_cast<float>(near - far)))
+			- 1.F;
 	static constexpr const std::array extents {-1.F, 1.F};
 	static constexpr const auto cartesianExtents = extents * extents;
 	return cartesianExtents * [&depth, this, &clampToSeaFloor](const auto & extent) {
diff --git a/gfx/gl/camera.h b/gfx/gl/camera.h
index 469df0d..eca7b8f 100644
--- a/gfx/gl/camera.h
+++ b/gfx/gl/camera.h
@@ -7,7 +7,7 @@
 
 class Camera {
 public:
-	Camera(Position3D, Angle fov, Angle aspect, Distance zNear, Distance zFar);
+	Camera(GlobalPosition3D, Angle fov, Angle aspect, GlobalDistance zNear, GlobalDistance zFar);
 
 	[[nodiscard]] glm::mat4
 	getViewProjection() const
@@ -18,7 +18,7 @@ public:
 	[[nodiscard]] Ray unProject(const ScreenRelCoord &) const;
 
 	void
-	setPosition(const Position3D & p)
+	setPosition(const GlobalPosition3D & p)
 	{
 		position = p;
 		updateView();
@@ -39,23 +39,23 @@ public:
 	}
 
 	void
-	setView(const Position3D & p, const Direction3D & f)
+	setView(const GlobalPosition3D & p, const Direction3D & f)
 	{
 		position = p;
 		setForward(f);
 	}
 
 	void
-	setView(const Position3D & p, const Direction3D & f, const Direction3D & u)
+	setView(const GlobalPosition3D & p, const Direction3D & f, const Direction3D & u)
 	{
 		position = p;
 		setView(f, u);
 	}
 
 	void
-	lookAt(const Position3D & target)
+	lookAt(const GlobalPosition3D & target)
 	{
-		setForward(glm::normalize(target - position));
+		setForward(glm::normalize(RelativePosition3D(target - position)));
 	}
 
 	[[nodiscard]] auto
@@ -70,18 +70,18 @@ public:
 		return position;
 	}
 
-	[[nodiscard]] std::array<glm::vec4, 4> extentsAtDist(float) const;
+	[[nodiscard]] std::array<GlobalPosition4D, 4> extentsAtDist(GlobalDistance) const;
 
 	[[nodiscard]] static Direction3D upFromForward(const Direction3D & forward);
 
 private:
 	void updateView();
 
-	Position3D position;
+	GlobalPosition3D position;
 	Direction3D forward;
 	Direction3D up;
 
-	float near, far;
+	GlobalDistance near, far;
 	glm::mat4 projection;
 	glm::mat4 viewProjection, inverseViewProjection;
 };
diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index 53178e5..582c28c 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 {{-1250000.0F, -1250000.0F, 35.0F}, quarter_pi, ratio(s), 100.F, 10000000.0F}, size {s}, output {o},
+	camera {{-1250000, -1250000, 35.0F}, quarter_pi, ratio(s), 100, 10000000}, 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/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 66905df..deb0630 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -79,12 +79,12 @@ constexpr std::array<std::array<TextureRelRegion, ShadowMapper::SHADOW_BANDS>, S
 						{0.25F, 0.25F, 0.75F, 0.75F}, // upper right
 				}},
 		}};
-constexpr std::array<float, ShadowMapper::SHADOW_BANDS + 1> shadowBands {
-		1000.F,
-		250000.F,
-		750000.F,
-		2500000.F,
-		10000000.F,
+constexpr std::array<GlobalDistance, ShadowMapper::SHADOW_BANDS + 1> shadowBands {
+		1000,
+		250000,
+		750000,
+		2500000,
+		10000000,
 };
 static_assert(viewports.size() == shadowMapRegions.size());
 static_assert(shadowBands.size() == shadowMapRegions.size() + 1);
@@ -114,7 +114,7 @@ ShadowMapper::getBandViewExtents(const Camera & camera, const glm::mat4 & lightV
 		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) {
+		if (std::none_of(extents.begin(), extents.end(), [targetDist = dist - 1](const auto & e) {
 				return e.w > targetDist;
 			})) {
 			break;
@@ -130,8 +130,8 @@ ShadowMapper::update(const SceneProvider & scene, const Direction3D & dir, const
 	glClear(GL_DEPTH_BUFFER_BIT);
 	glCullFace(GL_FRONT);
 
-	const auto lightView = glm::lookAt(camera.getPosition(), camera.getPosition() + dir, up);
 	const auto lightViewDir = glm::lookAt(origin, dir, up);
+	const auto lightView = lightViewDir * glm::translate(RelativePosition3D {-camera.getPosition()});
 	const auto lightViewPoint = camera.getPosition();
 	const auto bandViewExtents = getBandViewExtents(camera, lightView);
 
diff --git a/test/test-maths.cpp b/test/test-maths.cpp
index cc97250..3f8c2a0 100644
--- a/test/test-maths.cpp
+++ b/test/test-maths.cpp
@@ -261,7 +261,7 @@ BOOST_DATA_TEST_CASE(curve1,
 
 BOOST_AUTO_TEST_CASE(camera_clicks)
 {
-	Camera camera {::origin, ::half_pi, 1.25F, .1F, 10000.F};
+	Camera camera {::origin, ::half_pi, 1.25F, 1000, 10000000};
 	constexpr float centre {0.5F}, right {0.9F}, left {0.1F}, top {1.F}, bottom {0.F};
 	camera.setForward(::north);
 	BOOST_CHECK_EQUAL(camera.unProject({centre, centre}).start, ::origin);
diff --git a/test/test-render.cpp b/test/test-render.cpp
index cb6b1b4..22da73b 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -67,19 +67,19 @@ BOOST_GLOBAL_FIXTURE(ApplicationBase);
 BOOST_GLOBAL_FIXTURE(TestMainWindow);
 
 BOOST_DATA_TEST_CASE(cam,
-		boost::unit_test::data::xrange(0.5F, 30.F, 1.3F) * boost::unit_test::data::xrange(0.5F, 10.F, 0.3F)
-				* boost::unit_test::data::xrange(50.F, 500.F, 70.F),
+		boost::unit_test::data::xrange(500, 30000, 1300) * boost::unit_test::data::xrange(500, 10000, 300)
+				* boost::unit_test::data::xrange(50000, 500000, 70000),
 		dist, near, far)
 {
-	static constexpr glm::vec4 pos {-10, -10, 60, 0};
+	static constexpr GlobalPosition4D pos {-10, -10, 60000, 0};
 	const Camera cam {pos, half_pi, 1.F, near, far};
 
 	const auto e = cam.extentsAtDist(dist);
 
-	BOOST_CHECK_CLOSE_VEC(e[0], pos + glm::vec4(-dist, dist, -dist, dist));
-	BOOST_CHECK_CLOSE_VEC(e[1], pos + glm::vec4(-dist, dist, dist, dist));
-	BOOST_CHECK_CLOSE_VEC(e[2], pos + glm::vec4(dist, dist, -dist, dist));
-	BOOST_CHECK_CLOSE_VEC(e[3], pos + glm::vec4(dist, dist, dist, dist));
+	BOOST_CHECK_CLOSE_VECI(e[0], pos + GlobalPosition4D(-dist, dist, -dist, dist));
+	BOOST_CHECK_CLOSE_VECI(e[1], pos + GlobalPosition4D(-dist, dist, dist, dist));
+	BOOST_CHECK_CLOSE_VECI(e[2], pos + GlobalPosition4D(dist, dist, -dist, dist));
+	BOOST_CHECK_CLOSE_VECI(e[3], pos + GlobalPosition4D(dist, dist, dist, dist));
 }
 
 BOOST_FIXTURE_TEST_SUITE(w, TestRenderOutput);
-- 
cgit v1.2.3


From 04f42212ba67ec7d8160bf4a19c0b1283aec69bc Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Mon, 11 Dec 2023 20:49:52 +0000
Subject: Fix clamping to seafloor and add specific test

---
 gfx/gl/camera.cpp    |  6 +++---
 test/test-render.cpp | 12 ++++++++++++
 2 files changed, 15 insertions(+), 3 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/camera.cpp b/gfx/gl/camera.cpp
index a0d76ab..ff4c91e 100644
--- a/gfx/gl/camera.cpp
+++ b/gfx/gl/camera.cpp
@@ -41,9 +41,9 @@ Camera::extentsAtDist(const GlobalDistance dist) const
 	const auto clampToSeaFloor = [this, dist](GlobalPosition3D target) -> GlobalPosition4D {
 		target += position;
 		if (target.z < -1500) {
-			const auto diff = (target - position);
-			const auto something = (-1500 - position.z) / diff.z;
-			return {position + diff * something, dist};
+			const auto diff = target - position;
+			const auto limit = -1500 - position.z;
+			return {position + (limit * diff) / diff.z, (limit * dist) / diff.z};
 		}
 		return {target, dist};
 	};
diff --git a/test/test-render.cpp b/test/test-render.cpp
index 22da73b..37bacdd 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -82,6 +82,18 @@ BOOST_DATA_TEST_CASE(cam,
 	BOOST_CHECK_CLOSE_VECI(e[3], pos + GlobalPosition4D(dist, dist, dist, dist));
 }
 
+BOOST_AUTO_TEST_CASE(camSeaFloor)
+{
+	const Camera cam {{100, 200, 300}, half_pi, 1.F, 100, 2000};
+
+	const auto e = cam.extentsAtDist(2000);
+
+	BOOST_CHECK_CLOSE_VECI(e[0], GlobalPosition4D(-1700, 2000, -1500, 1800));
+	BOOST_CHECK_CLOSE_VECI(e[1], GlobalPosition4D(-1900, 2200, 2300, 2000));
+	BOOST_CHECK_CLOSE_VECI(e[2], GlobalPosition4D(1900, 2000, -1500, 1800));
+	BOOST_CHECK_CLOSE_VECI(e[3], GlobalPosition4D(2100, 2200, 2300, 2000));
+}
+
 BOOST_FIXTURE_TEST_SUITE(w, TestRenderOutput);
 
 BOOST_AUTO_TEST_CASE(basic)
-- 
cgit v1.2.3


From e4b85a5f84f73548def2162fc534625470404df1 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Wed, 13 Dec 2023 01:46:36 +0000
Subject: Basic support for saving intermediate render buffers

---
 gfx/gl/sceneRenderer.h |  2 +-
 test/test-render.cpp   | 20 ++++++++++++++++++--
 2 files changed, 19 insertions(+), 3 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/sceneRenderer.h b/gfx/gl/sceneRenderer.h
index 30fd8d3..7f72d76 100644
--- a/gfx/gl/sceneRenderer.h
+++ b/gfx/gl/sceneRenderer.h
@@ -19,7 +19,7 @@ public:
 
 	Camera camera;
 
-private:
+protected:
 	void renderQuad() const;
 
 	ScreenAbsCoord size;
diff --git a/test/test-render.cpp b/test/test-render.cpp
index 37bacdd..e2797a4 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -98,11 +98,27 @@ BOOST_FIXTURE_TEST_SUITE(w, TestRenderOutput);
 
 BOOST_AUTO_TEST_CASE(basic)
 {
-	SceneRenderer ss {size, output};
+	class TestSceneRenderer : public SceneRenderer {
+		using SceneRenderer::SceneRenderer;
+
+	public:
+		void
+		saveBuffers(const std::filesystem::path & prefix) const
+		{
+			std::filesystem::create_directories(prefix);
+			Texture::save(gAlbedoSpec, (prefix / "albedo.tga").c_str());
+			Texture::save(gPosition, (prefix / "position.tga").c_str());
+			Texture::saveNormal(gNormal, (prefix / "normal.tga").c_str());
+			Texture::save(gIllumination, (prefix / "illumination.tga").c_str());
+		}
+	};
+
+	TestSceneRenderer ss {size, output};
 	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");
+	ss.saveBuffers("/tmp/basic");
+	Texture::save(outImage, "/tmp/basic/final.tga");
 }
 
 BOOST_AUTO_TEST_CASE(terrain)
-- 
cgit v1.2.3


From 582b43ff308eecbdcaf0ab14994a0ddbdba1b701 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Fri, 15 Dec 2023 01:20:53 +0000
Subject: Support setting framebuffer texture format

Renames format to iformat to differentiate internal format from format
---
 gfx/gl/sceneRenderer.cpp | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index 582c28c..541af43 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -22,25 +22,25 @@ SceneRenderer::SceneRenderer(ScreenAbsCoord s, GLuint o) :
 	VertexArrayObject {displayVAO}.addAttribs<glm::i8vec4>(displayVBO, displayVAOdata);
 
 	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
-	const auto configuregdata
-			= [this](const GLuint data, const std::initializer_list<GLint> formats, const GLenum attachment) {
-				  glBindTexture(GL_TEXTURE_2D, data);
-				  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-				  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-				  for (const auto format : formats) {
-					  glTexImage2D(GL_TEXTURE_2D, 0, format, size.x, size.y, 0, GL_RGB, GL_BYTE, nullptr);
+	const auto configuregdata = [this](const GLuint data, const std::initializer_list<GLint> iformats,
+										const GLenum format, const GLenum attachment) {
+		glBindTexture(GL_TEXTURE_2D, data);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		for (const auto iformat : iformats) {
+			glTexImage2D(GL_TEXTURE_2D, 0, iformat, size.x, size.y, 0, format, GL_BYTE, nullptr);
 
-					  glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, GL_TEXTURE_2D, data, 0);
-					  if (glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) {
-						  return format;
-					  }
-				  }
-				  throw std::runtime_error("Framebuffer could not be completed!");
-			  };
-	configuregdata(gPosition, {GL_RGB32F}, GL_COLOR_ATTACHMENT0);
-	configuregdata(gNormal, {GL_RGB8_SNORM, GL_RGB16F}, GL_COLOR_ATTACHMENT1);
-	configuregdata(gAlbedoSpec, {GL_RGB8}, GL_COLOR_ATTACHMENT2);
-	configuregdata(gIllumination, {GL_RGB8}, GL_COLOR_ATTACHMENT3);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, GL_TEXTURE_2D, data, 0);
+			if (glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) {
+				return iformat;
+			}
+		}
+		throw std::runtime_error("Framebuffer could not be completed!");
+	};
+	configuregdata(gPosition, {GL_RGB32F}, GL_RGB, GL_COLOR_ATTACHMENT0);
+	configuregdata(gNormal, {GL_RGB8_SNORM, GL_RGB16F}, GL_RGB, GL_COLOR_ATTACHMENT1);
+	configuregdata(gAlbedoSpec, {GL_RGB8}, GL_RGB, GL_COLOR_ATTACHMENT2);
+	configuregdata(gIllumination, {GL_RGB8}, GL_RGB, GL_COLOR_ATTACHMENT3);
 
 	glBindRenderbuffer(GL_RENDERBUFFER, depth);
 	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, size.x, size.y);
-- 
cgit v1.2.3


From 14aa604389110f5da25e0c06ca4c6a753c497248 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Fri, 15 Dec 2023 01:46:22 +0000
Subject: Basic support for saving integer position buffer

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

(limited to 'gfx')

diff --git a/gfx/models/texture.cpp b/gfx/models/texture.cpp
index 1685d34..35f8d35 100644
--- a/gfx/models/texture.cpp
+++ b/gfx/models/texture.cpp
@@ -103,6 +103,12 @@ Texture::save(const glTexture & texture, const char * path)
 	save(texture, GL_BGR, GL_UNSIGNED_BYTE, 3, path, 2);
 }
 
+void
+Texture::savePosition(const glTexture & texture, const char * path)
+{
+	save(texture, GL_BGR_INTEGER, GL_UNSIGNED_BYTE, 3, path, 2);
+}
+
 void
 Texture::saveDepth(const glTexture & texture, const char * path)
 {
diff --git a/gfx/models/texture.h b/gfx/models/texture.h
index 5e1b440..5d40b39 100644
--- a/gfx/models/texture.h
+++ b/gfx/models/texture.h
@@ -40,6 +40,7 @@ public:
 	static void save(const glTexture &, const char * path);
 	static void saveDepth(const glTexture &, const char * path);
 	static void saveNormal(const glTexture &, const char * path);
+	static void savePosition(const glTexture &, const char * path);
 
 protected:
 	static void save(const glTexture &, GLenum, GLenum, uint8_t channels, const char * path, uint8_t tgaFormat);
-- 
cgit v1.2.3


From 467ef27cafa072bac1c9df633a99e33c0bbf0299 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 17 Dec 2023 12:13:19 +0000
Subject: Use a separate framebuffer for illumination phase

---
 gfx/gl/sceneRenderer.cpp | 20 ++++++++++++--------
 gfx/gl/sceneRenderer.h   |  2 +-
 2 files changed, 13 insertions(+), 9 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index 541af43..b88fb71 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -21,7 +21,6 @@ SceneRenderer::SceneRenderer(ScreenAbsCoord s, GLuint o) :
 	shader.setViewPort({0, 0, size.x, size.y});
 	VertexArrayObject {displayVAO}.addAttribs<glm::i8vec4>(displayVBO, displayVAOdata);
 
-	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
 	const auto configuregdata = [this](const GLuint data, const std::initializer_list<GLint> iformats,
 										const GLenum format, const GLenum attachment) {
 		glBindTexture(GL_TEXTURE_2D, data);
@@ -37,15 +36,23 @@ SceneRenderer::SceneRenderer(ScreenAbsCoord s, GLuint o) :
 		}
 		throw std::runtime_error("Framebuffer could not be completed!");
 	};
+
+	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
 	configuregdata(gPosition, {GL_RGB32F}, GL_RGB, GL_COLOR_ATTACHMENT0);
 	configuregdata(gNormal, {GL_RGB8_SNORM, GL_RGB16F}, GL_RGB, GL_COLOR_ATTACHMENT1);
 	configuregdata(gAlbedoSpec, {GL_RGB8}, GL_RGB, GL_COLOR_ATTACHMENT2);
-	configuregdata(gIllumination, {GL_RGB8}, GL_RGB, GL_COLOR_ATTACHMENT3);
+	constexpr std::array<unsigned int, 3> attachments {
+			GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2};
+	glDrawBuffers(attachments.size(), attachments.data());
 
 	glBindRenderbuffer(GL_RENDERBUFFER, depth);
 	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, size.x, size.y);
 	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth);
 
+	glBindFramebuffer(GL_FRAMEBUFFER, gBufferIll);
+	configuregdata(gIllumination, {GL_RGB8}, GL_RGB, GL_COLOR_ATTACHMENT0);
+	glDrawBuffer(GL_COLOR_ATTACHMENT0);
+
 	glBindFramebuffer(GL_FRAMEBUFFER, output);
 }
 
@@ -57,9 +64,6 @@ SceneRenderer::render(const SceneProvider & scene) const
 
 	// Geometry pass
 	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
-	static constexpr std::array<unsigned int, 3> attachments {
-			GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2};
-	glDrawBuffers(attachments.size(), attachments.data());
 	glEnable(GL_BLEND);
 	glEnable(GL_CULL_FACE);
 	glCullFace(GL_BACK);
@@ -70,7 +74,7 @@ SceneRenderer::render(const SceneProvider & scene) const
 	scene.content(shader);
 
 	// Illumination pass
-	glDrawBuffer(GL_COLOR_ATTACHMENT3);
+	glBindFramebuffer(GL_FRAMEBUFFER, gBufferIll);
 	glBlendFunc(GL_ONE, GL_ONE);
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, gPosition);
@@ -99,7 +103,7 @@ SceneRenderer::render(const SceneProvider & scene) const
 void
 SceneRenderer::setAmbientLight(const RGB & colour) const
 {
-	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
+	glBindFramebuffer(GL_FRAMEBUFFER, gBufferIll);
 	glClearColor(colour.r, colour.g, colour.b, 1.0F);
 	glClear(GL_COLOR_BUFFER_BIT);
 }
@@ -109,7 +113,7 @@ SceneRenderer::setDirectionalLight(const RGB & colour, const Direction3D & direc
 {
 	if (colour.r > 0 || colour.g > 0 || colour.b > 0) {
 		const auto lvp = shadowMapper.update(scene, direction, camera);
-		glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
+		glBindFramebuffer(GL_FRAMEBUFFER, gBufferIll);
 		glViewport(0, 0, size.x, size.y);
 		dirLight.use();
 		dirLight.setDirectionalLight(colour, direction, lvp.projections, lvp.regions, lvp.maps);
diff --git a/gfx/gl/sceneRenderer.h b/gfx/gl/sceneRenderer.h
index 7f72d76..c935f93 100644
--- a/gfx/gl/sceneRenderer.h
+++ b/gfx/gl/sceneRenderer.h
@@ -24,7 +24,7 @@ protected:
 
 	ScreenAbsCoord size;
 	GLuint output;
-	glFrameBuffer gBuffer;
+	glFrameBuffer gBuffer, gBufferIll;
 	glTexture gPosition, gNormal, gAlbedoSpec, gIllumination;
 	glRenderBuffer depth;
 
-- 
cgit v1.2.3


From cbc94ed8572cd4ea4e22ad5437b54eea055235d9 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 17 Dec 2023 12:14:35 +0000
Subject: Use 32bit integer texture for position render data

---
 gfx/gl/sceneRenderer.cpp           | 2 +-
 gfx/gl/shaders/directionalLight.fs | 6 +++---
 gfx/gl/shaders/landmass.fs         | 2 +-
 gfx/gl/shaders/material.fs         | 2 +-
 gfx/gl/shaders/materialOut.glsl    | 2 +-
 gfx/gl/shaders/pointLight.fs       | 2 +-
 gfx/gl/shaders/spotLight.fs        | 2 +-
 gfx/gl/shaders/water.fs            | 2 +-
 test/test-render.cpp               | 2 +-
 9 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index b88fb71..2854dea 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -38,7 +38,7 @@ SceneRenderer::SceneRenderer(ScreenAbsCoord s, GLuint o) :
 	};
 
 	glBindFramebuffer(GL_FRAMEBUFFER, gBuffer);
-	configuregdata(gPosition, {GL_RGB32F}, GL_RGB, GL_COLOR_ATTACHMENT0);
+	configuregdata(gPosition, {GL_RGB32I}, GL_RGB_INTEGER, GL_COLOR_ATTACHMENT0);
 	configuregdata(gNormal, {GL_RGB8_SNORM, GL_RGB16F}, GL_RGB, GL_COLOR_ATTACHMENT1);
 	configuregdata(gAlbedoSpec, {GL_RGB8}, GL_RGB, GL_COLOR_ATTACHMENT2);
 	constexpr std::array<unsigned int, 3> attachments {
diff --git a/gfx/gl/shaders/directionalLight.fs b/gfx/gl/shaders/directionalLight.fs
index ca10ef5..3756db7 100644
--- a/gfx/gl/shaders/directionalLight.fs
+++ b/gfx/gl/shaders/directionalLight.fs
@@ -7,7 +7,7 @@ out vec3 FragColor;
 
 in vec2 TexCoords;
 
-layout(binding = 0) uniform sampler2D gPosition;
+layout(binding = 0) uniform isampler2D gPosition;
 layout(binding = 1) uniform sampler2D gNormal;
 layout(binding = 2) uniform sampler2D shadowMap;
 
@@ -27,7 +27,7 @@ insideShadowCube(vec3 v)
 }
 
 float
-isShaded(vec3 Position)
+isShaded(ivec3 Position)
 {
 	for (uint m = 0u; m < lightViewProjectionCount; m++) {
 		vec3 PositionInLightSpace = (lightViewProjection[m] * vec4(Position, 1.0f)).xyz;
@@ -44,7 +44,7 @@ isShaded(vec3 Position)
 void
 main()
 {
-	const vec3 Position = texture(gPosition, TexCoords).xyz;
+	const ivec3 Position = texture(gPosition, TexCoords).xyz;
 	const vec3 Normal = texture(gNormal, TexCoords).rgb;
 	const float shaded = isShaded(Position);
 	FragColor = (1 - shaded) * max(dot(-lightDirection, Normal) * lightColour, 0);
diff --git a/gfx/gl/shaders/landmass.fs b/gfx/gl/shaders/landmass.fs
index 9865d11..fc43bf2 100644
--- a/gfx/gl/shaders/landmass.fs
+++ b/gfx/gl/shaders/landmass.fs
@@ -60,7 +60,7 @@ main()
 		}
 	}
 
-	gPosition = vec4(FragPos, 1);
+	gPosition = ivec4(FragPos, 1);
 	gNormal = vec4(Normal, 1);
 	gAlbedoSpec = vec4(color, 1);
 }
diff --git a/gfx/gl/shaders/material.fs b/gfx/gl/shaders/material.fs
index 20fa8ab..5b93707 100644
--- a/gfx/gl/shaders/material.fs
+++ b/gfx/gl/shaders/material.fs
@@ -42,7 +42,7 @@ main()
 {
 	vec4 textureColour = getTextureColour(Material, TexCoords);
 	float opaque = step(0.5, mix(textureColour.a, 1, Colour.a));
-	gPosition = vec4(FragPos, opaque);
+	gPosition = ivec4(FragPos, opaque);
 	gNormal = vec4(Normal, opaque);
 	gl_FragDepth = mix(1.0, gl_FragCoord.z, opaque);
 	gAlbedoSpec = mix(textureColour, vec4(Colour.rgb, 1), Colour.a);
diff --git a/gfx/gl/shaders/materialOut.glsl b/gfx/gl/shaders/materialOut.glsl
index dc5f8e8..846825e 100644
--- a/gfx/gl/shaders/materialOut.glsl
+++ b/gfx/gl/shaders/materialOut.glsl
@@ -1,3 +1,3 @@
-layout(location = 0) out vec4 gPosition;
+layout(location = 0) out ivec4 gPosition;
 layout(location = 1) out vec4 gNormal;
 layout(location = 2) out vec4 gAlbedoSpec;
diff --git a/gfx/gl/shaders/pointLight.fs b/gfx/gl/shaders/pointLight.fs
index 1a68df8..ba327b6 100644
--- a/gfx/gl/shaders/pointLight.fs
+++ b/gfx/gl/shaders/pointLight.fs
@@ -3,7 +3,7 @@
 
 out vec3 FragColor;
 
-layout(binding = 0) uniform sampler2D gPosition;
+layout(binding = 0) uniform isampler2D gPosition;
 layout(binding = 1) uniform sampler2D gNormal;
 uniform ivec4 viewPort;
 uniform vec3 colour;
diff --git a/gfx/gl/shaders/spotLight.fs b/gfx/gl/shaders/spotLight.fs
index 78b8f72..937f922 100644
--- a/gfx/gl/shaders/spotLight.fs
+++ b/gfx/gl/shaders/spotLight.fs
@@ -3,7 +3,7 @@
 
 out vec3 FragColor;
 
-layout(binding = 0) uniform sampler2D gPosition;
+layout(binding = 0) uniform isampler2D gPosition;
 layout(binding = 1) uniform sampler2D gNormal;
 uniform ivec4 viewPort;
 uniform vec3 colour;
diff --git a/gfx/gl/shaders/water.fs b/gfx/gl/shaders/water.fs
index 2ccc924..a0daa17 100644
--- a/gfx/gl/shaders/water.fs
+++ b/gfx/gl/shaders/water.fs
@@ -10,7 +10,7 @@ uniform vec3 waves;
 void
 main()
 {
-	gPosition = vec4(FragPos, 1);
+	gPosition = ivec4(FragPos, 1);
 	gNormal = vec4(Normal, 1);
 	gAlbedoSpec = texture(texture0, TexCoords);
 	gAlbedoSpec.a *= clamp(-FragPos.z * .0007, .1, 1.0);
diff --git a/test/test-render.cpp b/test/test-render.cpp
index e2797a4..66b4d46 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -107,7 +107,7 @@ BOOST_AUTO_TEST_CASE(basic)
 		{
 			std::filesystem::create_directories(prefix);
 			Texture::save(gAlbedoSpec, (prefix / "albedo.tga").c_str());
-			Texture::save(gPosition, (prefix / "position.tga").c_str());
+			Texture::savePosition(gPosition, (prefix / "position.tga").c_str());
 			Texture::saveNormal(gNormal, (prefix / "normal.tga").c_str());
 			Texture::save(gIllumination, (prefix / "illumination.tga").c_str());
 		}
-- 
cgit v1.2.3


From 41fb7a02d7b24c88f91164670a5bf2973fd666f1 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 17 Dec 2023 12:42:41 +0000
Subject: Fix output of position data to include model position

---
 gfx/gl/shaders/commonPoint.glsl | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/shaders/commonPoint.glsl b/gfx/gl/shaders/commonPoint.glsl
index 046da27..a9817fb 100644
--- a/gfx/gl/shaders/commonPoint.glsl
+++ b/gfx/gl/shaders/commonPoint.glsl
@@ -16,13 +16,11 @@ getMaterialDetail(uint midx)
 void
 main()
 {
-	vec4 worldPos = model * vec4(position, 1.0);
-
-	FragPos = worldPos.xyz;
+	FragPos = (model * vec4(position, 1.0)).xyz + modelPos;
 	TexCoords = texCoord;
 	Normal = (model * vec4(normal, 0.0)).xyz;
 	Colour = colour;
 	Material = getMaterialDetail(material);
 
-	gl_Position = viewProjection * vec4(FragPos - viewPoint + modelPos, 1);
+	gl_Position = viewProjection * vec4(FragPos - viewPoint, 1);
 }
-- 
cgit v1.2.3


From 512a47b2b8a7248b640441a828c2ea5f97dc385f Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 17 Dec 2023 18:57:15 +0000
Subject: Use new calc types in camera extents to address overflow

---
 gfx/gl/camera.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/camera.cpp b/gfx/gl/camera.cpp
index ff4c91e..06e409e 100644
--- a/gfx/gl/camera.cpp
+++ b/gfx/gl/camera.cpp
@@ -41,9 +41,9 @@ Camera::extentsAtDist(const GlobalDistance dist) const
 	const auto clampToSeaFloor = [this, dist](GlobalPosition3D target) -> GlobalPosition4D {
 		target += position;
 		if (target.z < -1500) {
-			const auto diff = target - position;
-			const auto limit = -1500 - position.z;
-			return {position + (limit * diff) / diff.z, (limit * dist) / diff.z};
+			const CalcPosition3D diff = target - position;
+			const CalcDistance limit = -1500 - position.z;
+			return {position + GlobalPosition3D((limit * diff) / diff.z), (limit * dist) / diff.z};
 		}
 		return {target, dist};
 	};
-- 
cgit v1.2.3


From edb63bcb5fd140d0d4db71e170a43f767a4b70be Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sun, 17 Dec 2023 18:58:53 +0000
Subject: Run shadow mapper in camera relative space

---
 gfx/gl/sceneRenderer.cpp           | 10 ++++++----
 gfx/gl/sceneRenderer.h             |  8 ++++----
 gfx/gl/shaders/directionalLight.fs |  7 ++++---
 gfx/gl/shadowMapper.cpp            | 16 ++++++++--------
 4 files changed, 22 insertions(+), 19 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/sceneRenderer.cpp b/gfx/gl/sceneRenderer.cpp
index 2854dea..c856279 100644
--- a/gfx/gl/sceneRenderer.cpp
+++ b/gfx/gl/sceneRenderer.cpp
@@ -116,7 +116,7 @@ SceneRenderer::setDirectionalLight(const RGB & colour, const Direction3D & direc
 		glBindFramebuffer(GL_FRAMEBUFFER, gBufferIll);
 		glViewport(0, 0, size.x, size.y);
 		dirLight.use();
-		dirLight.setDirectionalLight(colour, direction, lvp.projections, lvp.regions, lvp.maps);
+		dirLight.setDirectionalLight(colour, direction, camera.getPosition(), lvp.projections, lvp.regions, lvp.maps);
 		renderQuad();
 	}
 }
@@ -131,7 +131,8 @@ SceneRenderer::renderQuad() const
 
 SceneRenderer::DirectionalLightProgram::DirectionalLightProgram() :
 	Program {lighting_vs, directionalLight_fs}, directionLoc {*this, "lightDirection"},
-	colourLoc {*this, "lightColour"}, lightViewProjectionLoc {*this, "lightViewProjection"},
+	colourLoc {*this, "lightColour"}, lightPointLoc {*this, "lightPoint"},
+	lightViewProjectionLoc {*this, "lightViewProjection"},
 	lightViewProjectionCountLoc {*this, "lightViewProjectionCount"},
 	lightViewShadowMapRegionLoc {*this, "shadowMapRegion"}
 {
@@ -139,12 +140,13 @@ SceneRenderer::DirectionalLightProgram::DirectionalLightProgram() :
 
 void
 SceneRenderer::DirectionalLightProgram::setDirectionalLight(const RGB & c, const Direction3D & d,
-		const std::span<const glm::mat4x4> lvp, const std::span<const TextureRelRegion> shadowMapRegions,
-		std::size_t maps) const
+		const GlobalPosition3D & p, 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));
 	const auto nd = glm::normalize(d);
 	glUniform3fv(directionLoc, 1, glm::value_ptr(nd));
+	glUniform3iv(lightPointLoc, 1, glm::value_ptr(p));
 	glUniform1ui(lightViewProjectionCountLoc, static_cast<GLuint>(maps));
 	glUniformMatrix4fv(lightViewProjectionLoc, static_cast<GLsizei>(maps), GL_FALSE, glm::value_ptr(lvp.front()));
 	glUniform4fv(lightViewShadowMapRegionLoc, static_cast<GLsizei>(maps), glm::value_ptr(shadowMapRegions.front()));
diff --git a/gfx/gl/sceneRenderer.h b/gfx/gl/sceneRenderer.h
index c935f93..797ecf1 100644
--- a/gfx/gl/sceneRenderer.h
+++ b/gfx/gl/sceneRenderer.h
@@ -39,12 +39,12 @@ protected:
 		DirectionalLightProgram();
 		using Program::use;
 
-		void setDirectionalLight(const RGB &, const Direction3D &, const std::span<const glm::mat4x4>,
-				const std::span<const TextureRelRegion>, std::size_t maps) const;
+		void setDirectionalLight(const RGB &, const Direction3D &, const GlobalPosition3D &,
+				const std::span<const glm::mat4x4>, const std::span<const TextureRelRegion>, std::size_t maps) const;
 
 	private:
-		RequiredUniformLocation directionLoc, colourLoc, lightViewProjectionLoc, lightViewProjectionCountLoc,
-				lightViewShadowMapRegionLoc;
+		RequiredUniformLocation directionLoc, colourLoc, lightPointLoc, lightViewProjectionLoc,
+				lightViewProjectionCountLoc, lightViewShadowMapRegionLoc;
 	};
 
 	DeferredLightProgram lighting;
diff --git a/gfx/gl/shaders/directionalLight.fs b/gfx/gl/shaders/directionalLight.fs
index 3756db7..f36d83f 100644
--- a/gfx/gl/shaders/directionalLight.fs
+++ b/gfx/gl/shaders/directionalLight.fs
@@ -13,6 +13,7 @@ layout(binding = 2) uniform sampler2D shadowMap;
 
 uniform vec3 lightDirection;
 uniform vec3 lightColour;
+uniform ivec3 lightPoint;
 uniform mat4 lightViewProjection[MAX_MAPS];
 uniform vec4 shadowMapRegion[MAX_MAPS];
 uniform uint lightViewProjectionCount;
@@ -27,10 +28,10 @@ insideShadowCube(vec3 v)
 }
 
 float
-isShaded(ivec3 Position)
+isShaded(vec4 Position)
 {
 	for (uint m = 0u; m < lightViewProjectionCount; m++) {
-		vec3 PositionInLightSpace = (lightViewProjection[m] * vec4(Position, 1.0f)).xyz;
+		const vec3 PositionInLightSpace = (lightViewProjection[m] * Position).xyz;
 		const float inside = insideShadowCube(PositionInLightSpace);
 		if (inside > 0) {
 			const float lightSpaceDepth
@@ -44,7 +45,7 @@ isShaded(ivec3 Position)
 void
 main()
 {
-	const ivec3 Position = texture(gPosition, TexCoords).xyz;
+	const vec4 Position = vec4(texture(gPosition, TexCoords).xyz - lightPoint, 1);
 	const vec3 Normal = texture(gNormal, TexCoords).rgb;
 	const float shaded = isShaded(Position);
 	FragColor = (1 - shaded) * max(dot(-lightDirection, Normal) * lightColour, 0);
diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index deb0630..74d93bd 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -106,14 +106,15 @@ struct DefinitionsInserter {
 };
 
 std::vector<std::array<Position3D, 4>>
-ShadowMapper::getBandViewExtents(const Camera & camera, const glm::mat4 & lightView)
+ShadowMapper::getBandViewExtents(const Camera & camera, const glm::mat4 & lightViewDir)
 {
 	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) -> Position3D {
-			return lightView * glm::vec4(Position3D {e}, 1);
-		});
+		bandViewExtents.emplace_back(
+				extents * [&lightViewDir, cameraPos = camera.getPosition()](const auto & e) -> Position3D {
+					return lightViewDir * RelativePosition4D(e.xyz() - cameraPos, 1);
+				});
 		if (std::none_of(extents.begin(), extents.end(), [targetDist = dist - 1](const auto & e) {
 				return e.w > targetDist;
 			})) {
@@ -131,14 +132,13 @@ ShadowMapper::update(const SceneProvider & scene, const Direction3D & dir, const
 	glCullFace(GL_FRONT);
 
 	const auto lightViewDir = glm::lookAt(origin, dir, up);
-	const auto lightView = lightViewDir * glm::translate(RelativePosition3D {-camera.getPosition()});
 	const auto lightViewPoint = camera.getPosition();
-	const auto bandViewExtents = getBandViewExtents(camera, lightView);
+	const auto bandViewExtents = getBandViewExtents(camera, lightViewDir);
 
 	Definitions out;
 	std::transform(bandViewExtents.begin(), std::prev(bandViewExtents.end()), std::next(bandViewExtents.begin()),
 			DefinitionsInserter {out},
-			[&scene, this, &lightView, bands = bandViewExtents.size() - 2, &out, &lightViewPoint, &lightViewDir](
+			[&scene, this, bands = bandViewExtents.size() - 2, &out, &lightViewPoint, &lightViewDir](
 					const auto & near, const auto & far) {
 				const auto extents_minmax = [extents = std::span {near.begin(), far.end()}](auto && comp) {
 					const auto mm = std::minmax_element(extents.begin(), extents.end(), comp);
@@ -158,7 +158,7 @@ ShadowMapper::update(const SceneProvider & scene, const Direction3D & dir, const
 				glViewport(size.x >> viewport.x, size.y >> viewport.y, size.x >> viewport.z, size.y >> viewport.w);
 				scene.shadows(*this);
 
-				return std::make_pair(lightProjection * lightView, shadowMapRegions[bands][out.maps]);
+				return std::make_pair(lightViewDirProjection, shadowMapRegions[bands][out.maps]);
 			});
 
 	glCullFace(GL_BACK);
-- 
cgit v1.2.3


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

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

(limited to 'gfx')

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


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

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

(limited to 'gfx')

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


From 8635bb43078dec951da63e3a4442f6a2f70ac686 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Mon, 1 Jan 2024 11:36:26 +0000
Subject: Simplify and 'fix' the wave cycle

---
 gfx/gl/sceneShader.cpp  | 3 +--
 gfx/gl/shaders/water.fs | 1 -
 gfx/gl/shaders/water.vs | 6 +++---
 3 files changed, 4 insertions(+), 6 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/sceneShader.cpp b/gfx/gl/sceneShader.cpp
index 57c8bb7..ccc1a1d 100644
--- a/gfx/gl/sceneShader.cpp
+++ b/gfx/gl/sceneShader.cpp
@@ -85,8 +85,7 @@ void
 SceneShader::WaterProgram::use(float waveCycle) const
 {
 	Program::use();
-	Position3D waves {waveCycle, 0.F, 0.F};
-	glUniform3fv(waveLoc, 1, glm::value_ptr(waves));
+	glUniform1f(waveLoc, waveCycle);
 }
 
 SceneShader::PointLightShader::PointLightShader() :
diff --git a/gfx/gl/shaders/water.fs b/gfx/gl/shaders/water.fs
index a0daa17..8891733 100644
--- a/gfx/gl/shaders/water.fs
+++ b/gfx/gl/shaders/water.fs
@@ -5,7 +5,6 @@ include(`materialInterface.glsl')
 include(`materialOut.glsl')
 
 uniform sampler2D texture0;
-uniform vec3 waves;
 
 void
 main()
diff --git a/gfx/gl/shaders/water.vs b/gfx/gl/shaders/water.vs
index f609d9e..f6c7c8f 100644
--- a/gfx/gl/shaders/water.vs
+++ b/gfx/gl/shaders/water.vs
@@ -5,13 +5,13 @@ include(`materialInterface.glsl')
 
 uniform mat4 viewProjection;
 uniform ivec3 viewPoint;
-uniform vec3 waves;
+uniform float waves;
 
 void
 main()
 {
-	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);
+	vec3 wpos = vec3(position.x + (cos(waves) * 1000.0), position.y + (cos(waves * 0 / 2) * 1000.0),
+			cos(waves + (position.x / 1000000.0) + (position.y / 8000.0)) * 300.0);
 
 	FragPos = vec3(wpos.xy, position.z);
 	TexCoords = texCoord;
-- 
cgit v1.2.3


From fe8f9775cce008465fcca2d6783bd7be0d64f77c Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Mon, 1 Jan 2024 11:49:46 +0000
Subject: Remove legacy Position types from shadowMapper

---
 gfx/gl/shadowMapper.cpp | 11 +++++------
 gfx/gl/shadowMapper.h   |  2 +-
 2 files changed, 6 insertions(+), 7 deletions(-)

(limited to 'gfx')

diff --git a/gfx/gl/shadowMapper.cpp b/gfx/gl/shadowMapper.cpp
index 74d93bd..6c8400e 100644
--- a/gfx/gl/shadowMapper.cpp
+++ b/gfx/gl/shadowMapper.cpp
@@ -105,16 +105,15 @@ struct DefinitionsInserter {
 	ShadowMapper::Definitions & out;
 };
 
-std::vector<std::array<Position3D, 4>>
+std::vector<std::array<RelativePosition3D, 4>>
 ShadowMapper::getBandViewExtents(const Camera & camera, const glm::mat4 & lightViewDir)
 {
-	std::vector<std::array<Position3D, 4>> bandViewExtents;
+	std::vector<std::array<RelativePosition3D, 4>> bandViewExtents;
 	for (const auto dist : shadowBands) {
 		const auto extents = camera.extentsAtDist(dist);
-		bandViewExtents.emplace_back(
-				extents * [&lightViewDir, cameraPos = camera.getPosition()](const auto & e) -> Position3D {
-					return lightViewDir * RelativePosition4D(e.xyz() - cameraPos, 1);
-				});
+		bandViewExtents.emplace_back(extents * [&lightViewDir, cameraPos = camera.getPosition()](const auto & e) {
+			return glm::mat3(lightViewDir) * (e.xyz() - cameraPos);
+		});
 		if (std::none_of(extents.begin(), extents.end(), [targetDist = dist - 1](const auto & e) {
 				return e.w > targetDist;
 			})) {
diff --git a/gfx/gl/shadowMapper.h b/gfx/gl/shadowMapper.h
index 01520ca..bf571f8 100644
--- a/gfx/gl/shadowMapper.h
+++ b/gfx/gl/shadowMapper.h
@@ -57,7 +57,7 @@ public:
 	}
 
 private:
-	[[nodiscard]] static std::vector<std::array<Position3D, 4>> getBandViewExtents(
+	[[nodiscard]] static std::vector<std::array<RelativePosition3D, 4>> getBandViewExtents(
 			const Camera &, const glm::mat4 & lightView);
 	glFrameBuffer depthMapFBO;
 	glTexture depthMap;
-- 
cgit v1.2.3


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

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

(limited to 'gfx')

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