Use a single buffer for the location/rotation data of all renderable objects

Removes the BufferedLocation and BufferedLocationUpdater mess.
Note: appears to break bogie rendering in asset factory test only, same
symptom as broken network render test? (out of date buffer data)

7 files changed, 46 insertions, 62 deletions

diff --git a/game/vehicles/railVehicle.cpp b/game/vehicles/railVehicle.cpp
index 61f6c93..5f92066 100644
--- a/game/vehicles/railVehicle.cpp
+++ b/game/vehicles/railVehicle.cpp
@@ -11,24 +11,14 @@
 #include <maths.h>
 #include <ray.h>
 
-RailVehicle::RailVehicle(RailVehicleClassPtr rvc) :
-	RailVehicleClass::Instance {rvc->instances.acquire()}, rvClass {std::move(rvc)},
-	location {[this](const BufferedLocation * l) {
-		this->get()->body.rotation = l->getRotationTransform();
-		this->get()->body.position = l->position();
-	}},
-	bogies {{
-			{[this](const BufferedLocation * l) {
-				 this->get()->front.rotation = l->getRotationTransform();
-				 this->get()->front.position = l->position();
-			 },
-					GlobalPosition3D {0, rvClass->wheelBase / 2.F, 0}},
-			{[this](const BufferedLocation * l) {
-				 this->get()->back.rotation = l->getRotationTransform();
-				 this->get()->back.position = l->position();
-			 },
-					GlobalPosition3D {0, -rvClass->wheelBase / 2.F, 0}},
-	}}
+RailVehicle::RailVehicle(RailVehicleClassPtr rvc, GlobalPosition3D position) :
+	RailVehicleClass::Instance {rvc->instances.acquire(
+			RailVehicleClass::commonLocationData.lock()->acquire(Location {.pos = position, .rot = {}}),
+			RailVehicleClass::commonLocationData.lock()->acquire(
+					Location {.pos = position + RelativePosition3D {0, rvc->wheelBase / 2.F, 0}, .rot = {}}),
+			RailVehicleClass::commonLocationData.lock()->acquire(
+					Location {.pos = position + RelativePosition3D {0, -rvc->wheelBase / 2.F, 0}, .rot = {}}))},
+	rvClass {std::move(rvc)}
 {
 }
 
@@ -36,23 +26,30 @@ void
 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(RelativePosition3D(b2Pos.position() - b1Pos.position()));
-	location.setLocation((b1Pos.position() + b2Pos.position()) / 2, {vector_pitch(diff), vector_yaw(diff), 0});
+	const auto & b1Pos = *(get()->front = t->getBogiePosition(t->linkDist, trailBy += overhang));
+	const auto & b2Pos = *(get()->back = t->getBogiePosition(t->linkDist, trailBy += rvClass->wheelBase));
+	const auto diff = glm::normalize(difference(b2Pos.position, b1Pos.position));
+	get()->body = Location {
+			.pos = midpoint(b1Pos.position, b2Pos.position), .rot = {vector_pitch(diff), vector_yaw(diff), 0}};
 	trailBy += 600.F + overhang;
 }
 
+Location
+RailVehicle::getLocation() const
+{
+	return {.pos = get()->body->position, .rot = get()->body->rotation};
+}
+
 bool
 RailVehicle::intersectRay(const Ray<GlobalPosition3D> & ray, BaryPosition & baryPos, RelativeDistance & distance) const
 {
 	constexpr const auto X = 1350.F;
 	const auto Y = this->rvClass->length / 2.F;
 	constexpr const auto Z = 3900.F;
-	const glm::mat3 moveBy = location.getRotationTransform();
-	const auto cornerVertices = cuboidCorners(-X, X, -Y, Y, 0.F, Z) * [&moveBy, this](const auto & corner) {
-		return location.position() + (moveBy * corner);
-	};
+	const auto cornerVertices
+			= cuboidCorners(-X, X, -Y, Y, 0.F, Z) * [body = this->get()->body.get()](const auto & corner) {
+				  return body->position + (body->rotationMatrix * corner);
+			  };
 	static constexpr const std::array<glm::vec<3, uint8_t>, 10> triangles {{
 			// Front
 			{0, 1, 2},
diff --git a/game/vehicles/railVehicle.h b/game/vehicles/railVehicle.h
index bf1e782..0f341f9 100644
--- a/game/vehicles/railVehicle.h
+++ b/game/vehicles/railVehicle.h
@@ -1,8 +1,6 @@
 #pragma once
 
-#include "gfx/gl/bufferedLocation.h"
 #include "railVehicleClass.h"
-#include <array>
 #include <game/selectable.h>
 #include <glm/glm.hpp>
 #include <memory>
@@ -12,16 +10,14 @@ class Train;
 
 class RailVehicle : Selectable, RailVehicleClass::Instance {
 public:
-	explicit RailVehicle(RailVehicleClassPtr rvc);
+	explicit RailVehicle(RailVehicleClassPtr rvc, GlobalPosition3D = {});
 
 	void move(const Train *, float & trailBy);
 
+	[[nodiscard]] Location getLocation() const;
 	[[nodiscard]] bool intersectRay(const Ray<GlobalPosition3D> &, BaryPosition &, RelativeDistance &) const override;
 
 	RailVehicleClassPtr rvClass;
-	using LV = RailVehicleClass::LocationVertex;
-	BufferedLocationUpdater location;
-	std::array<BufferedLocationUpdater, 2> bogies;
 };
 
 using RailVehiclePtr = std::unique_ptr<RailVehicle>;
diff --git a/game/vehicles/railVehicleClass.cpp b/game/vehicles/railVehicleClass.cpp
index 176fe82..4e9404c 100644
--- a/game/vehicles/railVehicleClass.cpp
+++ b/game/vehicles/railVehicleClass.cpp
@@ -7,7 +7,6 @@
 #include <location.h>
 #include <maths.h>
 #include <memory>
-#include <ranges>
 
 bool
 RailVehicleClass::persist(Persistence::PersistenceStore & store)
@@ -20,12 +19,10 @@ RailVehicleClass::persist(Persistence::PersistenceStore & store)
 std::any
 RailVehicleClass::createAt(const Location & position) const
 {
-	return std::make_shared<InstanceVertices<LocationVertex>::InstanceProxy>(instances.acquire(LocationVertex {
-			.body = {.rotation = position.getRotationTransform(), .position = position.pos},
-			.front = {.rotation = position.getRotationTransform(),
-					.position = {sincos(position.rot.x) * wheelBase * 0.5F, position.pos.z}},
-			.back = {.rotation = position.getRotationTransform(),
-					.position = {sincos(position.rot.x) * wheelBase * -0.5F, position.pos.z}},
+	return std::make_shared<InstanceVertices<InstanceVertex>::InstanceProxy>(instances.acquire(InstanceVertex {
+			.body = locationData->acquire(position),
+			.front = locationData->acquire(position + ((sincos(position.rot.x) * wheelBase * 0.5F) || 0.F)),
+			.back = locationData->acquire(position + ((sincos(position.rot.x) * wheelBase * -0.5F) || 0.F)),
 	}));
 }
 
@@ -34,22 +31,20 @@ RailVehicleClass::postLoad()
 {
 	texture = getTexture();
 	glDebugScope _ {0};
-	bodyMesh->configureVAO(instanceVAO, 0)
-			.addAttribs<LocationVertex, &LocationVertex::Part::rotation, &LocationVertex::Part::position>(1);
-	static_assert(sizeof(LocationVertex) == 144UL);
+	bodyMesh->configureVAO(instanceVAO, 0).addAttribs<InstanceVertex, &InstanceVertex::body>(1);
 }
 
 void
 RailVehicleClass::renderAllParts(const size_t count) const
 {
-	using PartPair = std::pair<Mesh::Ptr, LocationVertex::Part LocationVertex::*>;
+	using PartPair = std::pair<Mesh::Ptr, CommonLocationInstance InstanceVertex::*>;
 	const auto bufferName = instances.bufferName();
 	for (const auto & [mesh, part] : {
-				 PartPair {bodyMesh, &LocationVertex::body},
-				 PartPair {bogies.front(), &LocationVertex::front},
-				 PartPair {bogies.back(), &LocationVertex::back},
+				 PartPair {bodyMesh, &InstanceVertex::body},
+				 PartPair {bogies.front(), &InstanceVertex::front},
+				 PartPair {bogies.back(), &InstanceVertex::back},
 		 }) {
-		instanceVAO.useBuffer<LocationVertex>(1, bufferName, part);
+		instanceVAO.useBuffer<InstanceVertex>(1, bufferName, part);
 		mesh->drawInstanced(instanceVAO, static_cast<GLsizei>(count));
 	}
 }
diff --git a/game/vehicles/railVehicleClass.h b/game/vehicles/railVehicleClass.h
index fe27230..a635122 100644
--- a/game/vehicles/railVehicleClass.h
+++ b/game/vehicles/railVehicleClass.h
@@ -19,13 +19,8 @@ public:
 
 	[[nodiscard]] std::any createAt(const Location &) const override;
 
-	struct LocationVertex {
-		struct Part {
-			glm::mat3 rotation;
-			GlobalPosition3D position;
-		};
-
-		Part body, front, back;
+	struct InstanceVertex {
+		CommonLocationInstance body, front, back;
 	};
 
 	std::array<Mesh::Ptr, 2> bogies;
@@ -35,7 +30,7 @@ public:
 	float length;
 	float maxSpeed;
 
-	mutable InstanceVertices<LocationVertex> instances;
+	mutable InstanceVertices<InstanceVertex> instances;
 	using Instance = decltype(instances)::InstanceProxy;
 
 protected:
diff --git a/game/vehicles/train.cpp b/game/vehicles/train.cpp
index 2461d9c..c79fd17 100644
--- a/game/vehicles/train.cpp
+++ b/game/vehicles/train.cpp
@@ -21,6 +21,12 @@ Train::getBogiePosition(float linkDist, float dist) const
 	return b2Link.first->positionAt(b2linkDist, b2Link.second);
 }
 
+Location
+Train::getLocation() const
+{
+	return objects.front()->getLocation();
+}
+
 bool
 Train::intersectRay(const Ray<GlobalPosition3D> & ray, BaryPosition & baryPos, RelativeDistance & distance) const
 {
diff --git a/game/vehicles/train.h b/game/vehicles/train.h
index 88e30f9..9ca53a8 100644
--- a/game/vehicles/train.h
+++ b/game/vehicles/train.h
@@ -19,12 +19,7 @@ class Train : public Vehicle, public UniqueCollection<RailVehicle>, public Can<G
 public:
 	explicit Train(const Link::CPtr & link, float linkDist = 0) : Vehicle {link, linkDist} { }
 
-	[[nodiscard]] const Location &
-	getLocation() const override
-	{
-		return objects.front()->location;
-	}
-
+	[[nodiscard]] Location getLocation() const override;
 	[[nodiscard]] bool intersectRay(const Ray<GlobalPosition3D> &, BaryPosition &, RelativeDistance &) const override;
 
 	void tick(TickDuration elapsed) override;
diff --git a/game/vehicles/vehicle.h b/game/vehicles/vehicle.h
index c3b35b7..cca8ff0 100644
--- a/game/vehicles/vehicle.h
+++ b/game/vehicles/vehicle.h
@@ -18,7 +18,7 @@ public:
 	float linkDist; // distance along current link
 	float speed {}; // speed in m/s (~75 km/h)
 
-	[[nodiscard]] virtual const Location & getLocation() const = 0;
+	[[nodiscard]] virtual Location getLocation() const = 0;
 	Orders orders;
 
 	ActivityPtr currentActivity;