From 5e561d390dc82b08c20532de0952f428e7b14283 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Tue, 21 Feb 2023 19:34:16 +0000
Subject: Rename ModelFactory to AssetFactory

---
 test/test-assetFactory.cpp | 173 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 173 insertions(+)
 create mode 100644 test/test-assetFactory.cpp

(limited to 'test/test-assetFactory.cpp')

diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
new file mode 100644
index 0000000..64d6a62
--- /dev/null
+++ b/test/test-assetFactory.cpp
@@ -0,0 +1,173 @@
+#define BOOST_TEST_MODULE test_asset_factory
+
+#include "testHelpers.h"
+#include "testRenderOutput.h"
+#include <boost/test/data/test_case.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include "assetFactory/assetFactory.h"
+#include "assetFactory/factoryMesh.h"
+#include "assetFactory/object.h"
+#include "gfx/gl/sceneRenderer.h"
+#include "lib/collection.hpp"
+#include "lib/location.hpp"
+#include "testMainWindow.h"
+#include "ui/applicationBase.h"
+
+BOOST_GLOBAL_FIXTURE(ApplicationBase);
+BOOST_GLOBAL_FIXTURE(TestMainWindow);
+
+const std::filesystem::path TMP {"/tmp"};
+class FactoryFixture : public TestRenderOutputSize<glm::ivec2 {2048, 2048}>, public SceneProvider {
+public:
+	FactoryFixture() : sceneRenderer {size, output} { }
+	~FactoryFixture()
+	{
+		glDisable(GL_DEBUG_OUTPUT);
+		auto outpath = (TMP / boost::unit_test::framework::current_test_case().full_name()).replace_extension(".tga");
+		std::filesystem::create_directories(outpath.parent_path());
+		Texture::save(outImage, size, outpath.c_str());
+	}
+	void
+	content(const SceneShader & shader) const override
+	{
+		shader.basic.use(Location {{0, 0, 0}, {0, 0, 0}});
+		meshes.apply(&Mesh::Draw);
+	}
+	void
+	lights(const SceneShader & shader) const override
+	{
+		shader.pointLight.add({-3, 1, 5}, {1, 1, 1}, .1F);
+	}
+	void
+	environment(const SceneShader &, const SceneRenderer & sceneRenderer) const override
+	{
+		sceneRenderer.setAmbientLight({.2, .2, .2});
+		sceneRenderer.setDirectionalLight({.3, .3, .3}, east + south + south + down, *this);
+	}
+	void
+	shadows(const ShadowMapper & mapper) const override
+	{
+		mapper.dynamicPoint.use(Location {{0, 0, 0}, {0, 0, 0}});
+		meshes.apply(&Mesh::Draw);
+	}
+	void
+	render(float dist = 10.f)
+	{
+		sceneRenderer.camera.setView({dist, dist, dist}, south + west + down);
+		sceneRenderer.render(*this);
+	}
+	Collection<const Mesh> meshes;
+
+private:
+	SceneRenderer sceneRenderer;
+};
+
+BOOST_FIXTURE_TEST_SUITE(m, FactoryFixture);
+BOOST_AUTO_TEST_CASE(brush47)
+{
+	AssetFactory assetFactory;
+	{
+		auto wheel = std::make_shared<Object>("wheel");
+		{
+			auto wheelCylinder = wheel->uses.emplace_back(std::make_shared<Use>());
+			wheelCylinder->type = assetFactory.shapes.at("cylinder");
+			wheelCylinder->position = {0, 0, 0.571};
+			wheelCylinder->scale = {1.142, 1.142, 0.07};
+			wheelCylinder->rotation = {0, 0, half_pi};
+			wheelCylinder->colour = "#2C3539";
+		}
+		assetFactory.shapes.emplace(wheel->id, wheel);
+	}
+	{
+		auto axel = std::make_shared<Object>("axel");
+		for (float x : {-1.f, 1.f}) {
+			auto wheel = axel->uses.emplace_back(std::make_shared<Use>());
+			wheel->type = assetFactory.shapes.at("wheel");
+			wheel->position = {x * 0.717f, 0, 0};
+			wheel->rotation = {0, x == 1.f ? pi : 0.f, 0};
+		}
+		assetFactory.shapes.emplace(axel->id, axel);
+	}
+	{
+		auto bogey = std::make_shared<Object>("bogey");
+		for (float y : {-2.f, 0.f, 2.f}) {
+			auto axel = bogey->uses.emplace_back(std::make_shared<Use>());
+			axel->type = assetFactory.shapes.at("axel");
+			axel->position = {0, y, 0};
+		}
+		assetFactory.shapes.emplace(bogey->id, bogey);
+	}
+	FactoryMesh::Collection factoryMeshes;
+	{
+		unsigned short b {0};
+		for (float y : {-6.f, 6.f}) {
+			auto bogey = factoryMeshes.emplace_back(std::make_shared<FactoryMesh>());
+			bogey->id = "bogey" + std::to_string(b);
+			auto bogeyUse = bogey->uses.emplace_back(std::make_shared<Use>());
+			bogeyUse->type = assetFactory.shapes.at("bogey");
+			bogeyUse->position = {0, y, 0};
+			bogeyUse->rotation = {0, b * pi, 0};
+			b++;
+		}
+	}
+	{
+		auto body = factoryMeshes.emplace_back(std::make_shared<FactoryMesh>());
+		body->id = "body";
+		body->size = {2.69f, 19.38f, 3.9f};
+		{
+			auto bodyLower = body->uses.emplace_back(std::make_shared<Use>());
+			bodyLower->type = assetFactory.shapes.at("cuboid");
+			bodyLower->position = {0, 0, 1.2};
+			bodyLower->scale = {2.69, 19.38, 1.5};
+			bodyLower->colour = "#1111DD";
+			bodyLower->faceControllers["bottom"].colour = "#2C3539";
+			auto & bodyUpper = bodyLower->faceControllers["top"];
+			bodyUpper.type = "extrude";
+			bodyUpper.scale = {1, .95f, 1};
+			bodyUpper.position = {0, 0, 1.0};
+			auto & roof = bodyUpper.faceControllers["top"];
+			roof.type = "extrude";
+			roof.scale = {.6f, .9f, 0};
+			roof.position = {0, 0, 0.2};
+			roof.smooth = true;
+		}
+		{
+			auto batteryBox = body->uses.emplace_back(std::make_shared<Use>());
+			batteryBox->type = assetFactory.shapes.at("cuboid");
+			batteryBox->position = {0, 0, .2};
+			batteryBox->scale = {2.6, 4.5, 1};
+			batteryBox->colour = "#2C3539";
+		}
+	}
+	std::transform(factoryMeshes.begin(), factoryMeshes.end(), std::back_inserter(meshes.objects),
+			[](const FactoryMesh::CPtr & factoryMesh) -> Mesh::Ptr {
+				return factoryMesh->createMesh();
+			});
+
+	render(20);
+}
+BOOST_AUTO_TEST_CASE(brush47xml)
+{
+	auto mf = AssetFactory::loadXML(RESDIR "/brush47.xml");
+	BOOST_REQUIRE(mf);
+	BOOST_REQUIRE_EQUAL(6, mf->shapes.size());
+	BOOST_CHECK(mf->shapes.at("plane"));
+	BOOST_CHECK(mf->shapes.at("cylinder"));
+	BOOST_CHECK(mf->shapes.at("cuboid"));
+	BOOST_CHECK(mf->shapes.at("wheel"));
+	BOOST_CHECK(mf->shapes.at("axel"));
+	auto bogey = mf->shapes.at("bogey");
+	BOOST_REQUIRE(bogey);
+	auto bogeyObj = std::dynamic_pointer_cast<const Object>(bogey);
+	BOOST_CHECK_EQUAL(3, bogeyObj->uses.size());
+
+	FactoryMesh::Collection factoryMeshes;
+	std::transform(factoryMeshes.begin(), factoryMeshes.end(), std::back_inserter(meshes.objects),
+			[](const FactoryMesh::CPtr & factoryMesh) -> Mesh::Ptr {
+				return factoryMesh->createMesh();
+			});
+
+	render(20);
+}
+BOOST_AUTO_TEST_SUITE_END();
-- 
cgit v1.2.3


From df2a078c51cee464905c6fb1d1c7c4aa7873f6a1 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Wed, 22 Feb 2023 23:40:46 +0000
Subject: Implement loading asset, mesh and face definitions

---
 assetFactory/assetFactory.cpp   | 11 ++++++-
 assetFactory/assetFactory.h     | 18 +++++++++-
 assetFactory/faceController.cpp | 10 +++++-
 assetFactory/faceController.h   | 14 ++++++--
 assetFactory/factoryMesh.cpp    |  7 ++++
 assetFactory/factoryMesh.h      |  6 +++-
 assetFactory/use.cpp            |  5 +--
 assetFactory/use.h              |  2 +-
 res/brush47.xml                 | 24 ++++++++++++--
 test/test-assetFactory.cpp      | 73 +++++++++++++++++++++++------------------
 10 files changed, 126 insertions(+), 44 deletions(-)

(limited to 'test/test-assetFactory.cpp')

diff --git a/assetFactory/assetFactory.cpp b/assetFactory/assetFactory.cpp
index 470eacf..564ea28 100644
--- a/assetFactory/assetFactory.cpp
+++ b/assetFactory/assetFactory.cpp
@@ -27,5 +27,14 @@ bool
 AssetFactory::persist(Persistence::PersistenceStore & store)
 {
 	using MapObjects = Persistence::MapByMember<Shapes, std::shared_ptr<Object>>;
-	return STORE_TYPE && STORE_NAME_HELPER("object", shapes, MapObjects);
+	using MapAssets = Persistence::MapByMember<Assets>;
+	return STORE_TYPE && STORE_NAME_HELPER("object", shapes, MapObjects)
+			&& STORE_NAME_HELPER("asset", assets, MapAssets);
+}
+
+bool
+Asset::persist(Persistence::PersistenceStore & store)
+{
+	return STORE_TYPE && STORE_MEMBER(id) && STORE_MEMBER(name)
+			&& STORE_NAME_HELPER("mesh", meshes, Persistence::Appender<FactoryMesh::Collection>);
 }
diff --git a/assetFactory/assetFactory.h b/assetFactory/assetFactory.h
index 5cf90dd..9d79827 100644
--- a/assetFactory/assetFactory.h
+++ b/assetFactory/assetFactory.h
@@ -1,17 +1,33 @@
 #pragma once
 
+#include "factoryMesh.h"
 #include "persistence.h"
 #include "shape.h"
 #include <filesystem>
+#include <stdTypeDefs.hpp>
+
+class Asset : public Persistence::Persistable, public StdTypeDefs<Asset> {
+public:
+	std::string id;
+	std::string name;
+
+	FactoryMesh::Collection meshes;
+
+private:
+	friend Persistence::SelectionPtrBase<std::shared_ptr<Asset>, true>;
+	bool persist(Persistence::PersistenceStore & store) override;
+};
 
 class AssetFactory : public Persistence::Persistable {
 public:
-	using Shapes = std::map<std::string, Shape::CPtr, std::less<>>;
+	using Shapes = std::map<std::string, Shape::Ptr, std::less<>>;
+	using Assets = std::map<std::string, Asset::Ptr, std::less<>>;
 
 	AssetFactory();
 	[[nodiscard]] static std::shared_ptr<AssetFactory> loadXML(const std::filesystem::path &);
 
 	Shapes shapes;
+	Assets assets;
 
 private:
 	friend Persistence::SelectionPtrBase<std::shared_ptr<AssetFactory>, true>;
diff --git a/assetFactory/faceController.cpp b/assetFactory/faceController.cpp
index 7ec7820..499f7e4 100644
--- a/assetFactory/faceController.cpp
+++ b/assetFactory/faceController.cpp
@@ -52,10 +52,18 @@ FaceController::apply(ModelFactoryMesh & mesh, const std::string & name, Shape::
 					}
 				}
 				for (const auto & [name, faceController] : faceControllers) {
-					faceController.apply(mesh, name, newFaces);
+					faceController->apply(mesh, name, newFaces);
 				}
 				faces.merge(std::move(newFaces));
 			}
 		}
 	}
 }
+
+bool
+FaceController::persist(Persistence::PersistenceStore & store)
+{
+	return STORE_TYPE && STORE_MEMBER(id) && STORE_MEMBER(colour) && STORE_MEMBER(type) && STORE_MEMBER(smooth)
+			&& STORE_MEMBER(scale) && STORE_MEMBER(position) && STORE_MEMBER(rotation)
+			&& STORE_NAME_HELPER("face", faceControllers, Persistence::MapByMember<FaceControllers>);
+}
diff --git a/assetFactory/faceController.h b/assetFactory/faceController.h
index 9974caf..296210d 100644
--- a/assetFactory/faceController.h
+++ b/assetFactory/faceController.h
@@ -2,13 +2,14 @@
 
 #include "modelFactoryMesh_fwd.h"
 #include "mutation.h"
+#include "persistence.h"
 #include "shape.h"
 #include <map>
 #include <string>
 
-class FaceController : public Mutation {
+class FaceController : public Mutation, public Persistence::Persistable {
 public:
-	using FaceControllers = std::map<std::string, FaceController>;
+	using FaceControllers = std::map<std::string, std::unique_ptr<FaceController>>;
 
 	void apply(ModelFactoryMesh & mesh, const std::string & name, Shape::CreatedFaces & faces) const;
 
@@ -17,4 +18,13 @@ public:
 	std::string type;
 	bool smooth {false};
 	FaceControllers faceControllers;
+
+private:
+	friend Persistence::SelectionPtrBase<std::unique_ptr<FaceController>, false>;
+	bool persist(Persistence::PersistenceStore & store) override;
+	std::string
+	getId() const override
+	{
+		return {};
+	};
 };
diff --git a/assetFactory/factoryMesh.cpp b/assetFactory/factoryMesh.cpp
index baa031d..0fb72ad 100644
--- a/assetFactory/factoryMesh.cpp
+++ b/assetFactory/factoryMesh.cpp
@@ -29,3 +29,10 @@ FactoryMesh::createMesh() const
 	}
 	return std::make_shared<Mesh>(vertices, vectorOfN(vertices.size()));
 }
+
+bool
+FactoryMesh::persist(Persistence::PersistenceStore & store)
+{
+	return STORE_TYPE && STORE_MEMBER(id) && STORE_MEMBER(size)
+			&& STORE_NAME_HELPER("use", uses, Persistence::Appender<Use::Collection>);
+}
diff --git a/assetFactory/factoryMesh.h b/assetFactory/factoryMesh.h
index f850893..4b6d3e5 100644
--- a/assetFactory/factoryMesh.h
+++ b/assetFactory/factoryMesh.h
@@ -4,11 +4,15 @@
 #include "stdTypeDefs.hpp"
 #include "use.h"
 
-class FactoryMesh : public StdTypeDefs<FactoryMesh> {
+class FactoryMesh : public Persistence::Persistable, public StdTypeDefs<FactoryMesh> {
 public:
 	Mesh::Ptr createMesh() const;
 
 	std::string id;
 	glm::vec3 size;
 	Use::Collection uses;
+
+private:
+	friend Persistence::SelectionPtrBase<std::shared_ptr<FactoryMesh>, true>;
+	bool persist(Persistence::PersistenceStore & store) override;
 };
diff --git a/assetFactory/use.cpp b/assetFactory/use.cpp
index 3b574c3..1f28332 100644
--- a/assetFactory/use.cpp
+++ b/assetFactory/use.cpp
@@ -6,7 +6,7 @@ Use::createMesh(ModelFactoryMesh & mesh, const Mutation::Matrix & mutation) cons
 {
 	auto faces = type->createMesh(mesh, mutation * getMatrix());
 	for (const auto & [name, faceController] : faceControllers) {
-		faceController.apply(mesh, name, faces);
+		faceController->apply(mesh, name, faces);
 	}
 	return faces;
 }
@@ -27,5 +27,6 @@ bool
 Use::persist(Persistence::PersistenceStore & store)
 {
 	return STORE_TYPE && STORE_HELPER(type, Lookup) && STORE_MEMBER(position) && STORE_MEMBER(scale)
-			&& STORE_MEMBER(rotation);
+			&& STORE_MEMBER(rotation) && STORE_MEMBER(colour)
+			&& STORE_NAME_HELPER("face", faceControllers, Persistence::MapByMember<FaceControllers>);
 }
diff --git a/assetFactory/use.h b/assetFactory/use.h
index 96f07f6..853af23 100644
--- a/assetFactory/use.h
+++ b/assetFactory/use.h
@@ -8,7 +8,7 @@
 
 class Use : public StdTypeDefs<Use>, public Mutation, public Persistence::Persistable {
 public:
-	using FaceControllers = std::map<std::string, FaceController>;
+	using FaceControllers = std::map<std::string, std::unique_ptr<FaceController>>;
 
 	Shape::CreatedFaces createMesh(ModelFactoryMesh & mesh, const Mutation::Matrix & mutation) const;
 
diff --git a/res/brush47.xml b/res/brush47.xml
index 3c6705a..9cd654f 100644
--- a/res/brush47.xml
+++ b/res/brush47.xml
@@ -1,15 +1,33 @@
 <?xml version="1.0"?>
 <ilt p.id="assetFactory">
   <object id="wheel">
-    <use type="cylinder" position="0,0,0.571" scale="1.142,1.142,0.07" rotation="0,0,90"/>
+    <use type="cylinder" position="0,0,0.571" scale="1.142,1.142,0.07" rotation="0,0,1.5708"/>
   </object>
   <object id="axel">
     <use type="wheel" position="0.717,0,0"/>
-    <use type="wheel" position="-0.717,0,0" rotation="0,90,0"/>
+    <use type="wheel" position="-0.717,0,0" rotation="0,3.14159,0"/>
   </object>
-  <object id="bogey">
+  <object id="bogie">
     <use type="axel" position="0,0,0"/>
     <use type="axel" position="0,2,0"/>
     <use type="axel" position="0,-2,0"/>
   </object>
+  <asset id="brush-47" name="Brush 47">
+    <mesh id="body" size="2.69,19.38,3.9">
+      <use type="cuboid" position="0,0,1.2" scale="2.69,19.38,1.5" colour="#1111dd">
+        <face id="bottom" colour="#2C3539"/>
+        <face id="top" type="extrude" scale="1,0.95,1" position="0,0,1.0">
+          <face id="top" type="extrude" scale="0.6,0.9,0" position="0,0,0.2"/>
+          <!--smooth="true"-->
+        </face>
+      </use>
+      <use type="cuboid" position="0,0,0.2" scale="2.6,4.5,1" colour="#2C3539"/>
+    </mesh>
+    <mesh id="bogie1">
+      <use type="bogie" position="0,6,0"/>
+    </mesh>
+    <mesh id="bogie2">
+      <use type="bogie" position="0,-6,0" rotation="0,3.14159,0"/>
+    </mesh>
+  </asset>
 </ilt>
diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 64d6a62..fd7a41d 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -90,24 +90,24 @@ BOOST_AUTO_TEST_CASE(brush47)
 		assetFactory.shapes.emplace(axel->id, axel);
 	}
 	{
-		auto bogey = std::make_shared<Object>("bogey");
+		auto bogie = std::make_shared<Object>("bogie");
 		for (float y : {-2.f, 0.f, 2.f}) {
-			auto axel = bogey->uses.emplace_back(std::make_shared<Use>());
+			auto axel = bogie->uses.emplace_back(std::make_shared<Use>());
 			axel->type = assetFactory.shapes.at("axel");
 			axel->position = {0, y, 0};
 		}
-		assetFactory.shapes.emplace(bogey->id, bogey);
+		assetFactory.shapes.emplace(bogie->id, bogie);
 	}
 	FactoryMesh::Collection factoryMeshes;
 	{
 		unsigned short b {0};
 		for (float y : {-6.f, 6.f}) {
-			auto bogey = factoryMeshes.emplace_back(std::make_shared<FactoryMesh>());
-			bogey->id = "bogey" + std::to_string(b);
-			auto bogeyUse = bogey->uses.emplace_back(std::make_shared<Use>());
-			bogeyUse->type = assetFactory.shapes.at("bogey");
-			bogeyUse->position = {0, y, 0};
-			bogeyUse->rotation = {0, b * pi, 0};
+			auto bogie = factoryMeshes.emplace_back(std::make_shared<FactoryMesh>());
+			bogie->id = "bogie" + std::to_string(b);
+			auto bogieUse = bogie->uses.emplace_back(std::make_shared<Use>());
+			bogieUse->type = assetFactory.shapes.at("bogie");
+			bogieUse->position = {0, y, 0};
+			bogieUse->rotation = {0, b * pi, 0};
 			b++;
 		}
 	}
@@ -115,23 +115,25 @@ BOOST_AUTO_TEST_CASE(brush47)
 		auto body = factoryMeshes.emplace_back(std::make_shared<FactoryMesh>());
 		body->id = "body";
 		body->size = {2.69f, 19.38f, 3.9f};
-		{
-			auto bodyLower = body->uses.emplace_back(std::make_shared<Use>());
-			bodyLower->type = assetFactory.shapes.at("cuboid");
-			bodyLower->position = {0, 0, 1.2};
-			bodyLower->scale = {2.69, 19.38, 1.5};
-			bodyLower->colour = "#1111DD";
-			bodyLower->faceControllers["bottom"].colour = "#2C3539";
-			auto & bodyUpper = bodyLower->faceControllers["top"];
-			bodyUpper.type = "extrude";
-			bodyUpper.scale = {1, .95f, 1};
-			bodyUpper.position = {0, 0, 1.0};
-			auto & roof = bodyUpper.faceControllers["top"];
-			roof.type = "extrude";
-			roof.scale = {.6f, .9f, 0};
-			roof.position = {0, 0, 0.2};
-			roof.smooth = true;
-		}
+		auto bodyLower = body->uses.emplace_back(std::make_shared<Use>());
+		bodyLower->type = assetFactory.shapes.at("cuboid");
+		bodyLower->position = {0, 0, 1.2};
+		bodyLower->scale = {2.69, 19.38, 1.5};
+		bodyLower->colour = "#1111DD";
+		auto & bottom = bodyLower->faceControllers["bottom"];
+		bottom = std::make_unique<FaceController>();
+		bottom->colour = "#2C3539";
+		auto & bodyUpper = bodyLower->faceControllers["top"];
+		bodyUpper = std::make_unique<FaceController>();
+		bodyUpper->type = "extrude";
+		bodyUpper->scale = {1, .95f, 1};
+		bodyUpper->position = {0, 0, 1.0};
+		auto & roof = bodyUpper->faceControllers["top"];
+		roof = std::make_unique<FaceController>();
+		roof->type = "extrude";
+		roof->scale = {.6f, .9f, 0};
+		roof->position = {0, 0, 0.2};
+		roof->smooth = true;
 		{
 			auto batteryBox = body->uses.emplace_back(std::make_shared<Use>());
 			batteryBox->type = assetFactory.shapes.at("cuboid");
@@ -157,13 +159,20 @@ BOOST_AUTO_TEST_CASE(brush47xml)
 	BOOST_CHECK(mf->shapes.at("cuboid"));
 	BOOST_CHECK(mf->shapes.at("wheel"));
 	BOOST_CHECK(mf->shapes.at("axel"));
-	auto bogey = mf->shapes.at("bogey");
-	BOOST_REQUIRE(bogey);
-	auto bogeyObj = std::dynamic_pointer_cast<const Object>(bogey);
-	BOOST_CHECK_EQUAL(3, bogeyObj->uses.size());
+	auto bogie = mf->shapes.at("bogie");
+	BOOST_REQUIRE(bogie);
+	auto bogieObj = std::dynamic_pointer_cast<const Object>(bogie);
+	BOOST_CHECK_EQUAL(3, bogieObj->uses.size());
+	BOOST_CHECK_EQUAL(1, mf->assets.size());
+	auto brush47 = mf->assets.at("brush-47");
+	BOOST_REQUIRE(brush47);
+	BOOST_CHECK_EQUAL(3, brush47->meshes.size());
+	auto body = brush47->meshes.at(0);
+	BOOST_REQUIRE(body);
+	BOOST_CHECK_EQUAL("body", body->id);
+	BOOST_CHECK_EQUAL(2, body->uses.size());
 
-	FactoryMesh::Collection factoryMeshes;
-	std::transform(factoryMeshes.begin(), factoryMeshes.end(), std::back_inserter(meshes.objects),
+	std::transform(brush47->meshes.begin(), brush47->meshes.end(), std::back_inserter(meshes.objects),
 			[](const FactoryMesh::CPtr & factoryMesh) -> Mesh::Ptr {
 				return factoryMesh->createMesh();
 			});
-- 
cgit v1.2.3


From b7b9eb7bb9deb6704f276fb3b8fd67ba370caf3e Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Mon, 27 Feb 2023 19:38:14 +0000
Subject: Load the X11 RGB colour definitions into a map

---
 assetFactory/assetFactory.cpp | 28 +++++++++++++++++++++++++++-
 assetFactory/assetFactory.h   |  6 ++++++
 test/fixtures/rgb.txt         | 20 ++++++++++++++++++++
 test/test-assetFactory.cpp    | 30 ++++++++++++++++++++++++++++++
 4 files changed, 83 insertions(+), 1 deletion(-)
 create mode 100644 test/fixtures/rgb.txt

(limited to 'test/test-assetFactory.cpp')

diff --git a/assetFactory/assetFactory.cpp b/assetFactory/assetFactory.cpp
index 564ea28..016f29e 100644
--- a/assetFactory/assetFactory.cpp
+++ b/assetFactory/assetFactory.cpp
@@ -1,4 +1,5 @@
 #include "assetFactory.h"
+#include "collections.hpp"
 #include "cuboid.h"
 #include "cylinder.h"
 #include "modelFactoryMesh_fwd.h"
@@ -12,7 +13,8 @@ AssetFactory::AssetFactory() :
 			{"plane", std::make_shared<Plane>()},
 			{"cuboid", std::make_shared<Cuboid>()},
 			{"cylinder", std::make_shared<Cylinder>()},
-	}
+	},
+	colours {parseX11RGB("/usr/share/X11/rgb.txt")}
 {
 }
 
@@ -23,6 +25,30 @@ AssetFactory::loadXML(const std::filesystem::path & filename)
 	return Persistence::SAXParsePersistence {}.loadState<std::shared_ptr<AssetFactory>>(file);
 }
 
+AssetFactory::Colours
+AssetFactory::parseX11RGB(const char * path)
+{
+	filesystem::FileStar rgb {path, "r"};
+	Colours out;
+	glm::u8vec3 colour;
+	char inname[BUFSIZ];
+	while (fscanf(rgb, "%hhu %hhu %hhu %[^\n\r]s", &colour.r, &colour.g, &colour.b, inname) == 4) {
+		std::string name {inname};
+		normalizeColourName(name);
+		out.emplace(std::move(name), colour);
+	}
+	return out;
+}
+
+void
+AssetFactory::normalizeColourName(std::string & name)
+{
+	std::erase_if(name, ::isblank);
+	name *= [l = std::locale {}](auto & ch) {
+		ch = std::tolower(ch, l);
+	};
+}
+
 bool
 AssetFactory::persist(Persistence::PersistenceStore & store)
 {
diff --git a/assetFactory/assetFactory.h b/assetFactory/assetFactory.h
index 9d79827..a68b460 100644
--- a/assetFactory/assetFactory.h
+++ b/assetFactory/assetFactory.h
@@ -22,12 +22,18 @@ class AssetFactory : public Persistence::Persistable {
 public:
 	using Shapes = std::map<std::string, Shape::Ptr, std::less<>>;
 	using Assets = std::map<std::string, Asset::Ptr, std::less<>>;
+	using Colour = glm::u8vec3;
+	using Colours = std::map<std::string, Colour, std::less<>>;
 
 	AssetFactory();
 	[[nodiscard]] static std::shared_ptr<AssetFactory> loadXML(const std::filesystem::path &);
 
 	Shapes shapes;
 	Assets assets;
+	Colours colours;
+
+	static Colours parseX11RGB(const char * rgbtxtpath);
+	static void normalizeColourName(std::string &);
 
 private:
 	friend Persistence::SelectionPtrBase<std::shared_ptr<AssetFactory>, true>;
diff --git a/test/fixtures/rgb.txt b/test/fixtures/rgb.txt
new file mode 100644
index 0000000..2fab7af
--- /dev/null
+++ b/test/fixtures/rgb.txt
@@ -0,0 +1,20 @@
+127 255	  0		chartreuse1
+190 190 190		x11 gray
+169 169 169		DarkGrey
+  0 255 255		cyan
+173 173 173 		gray68
+202 225 255		LightSteelBlue1
+ 72 209 204		medium turquoise
+224 238 224		honeydew2
+238 197 145		burlywood2
+205 133  63		peru
+ 28  28  28 		gray11
+ 83 134 139		CadetBlue4
+139  76	 57		salmon4
+238 232 170		pale goldenrod
+112 128 144		slate grey
+255 255	  0		yellow1
+159 121 238		MediumPurple2
+190 190 190		gray
+ 66  66  66 		grey26
+0     0 139		DarkBlue
diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index fd7a41d..89f6bf0 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -11,6 +11,7 @@
 #include "gfx/gl/sceneRenderer.h"
 #include "lib/collection.hpp"
 #include "lib/location.hpp"
+#include "lib/stream_support.hpp"
 #include "testMainWindow.h"
 #include "ui/applicationBase.h"
 
@@ -180,3 +181,32 @@ BOOST_AUTO_TEST_CASE(brush47xml)
 	render(20);
 }
 BOOST_AUTO_TEST_SUITE_END();
+
+template<typename T> using InOut = std::tuple<T, T>;
+BOOST_DATA_TEST_CASE(normalizeColourName,
+		boost::unit_test::data::make<InOut<std::string>>({
+				{"", ""},
+				{"black", "black"},
+				{" black ", "black"},
+				{" b l a c k ", "black"},
+				{" B L A c k ", "black"},
+				{"BLAck ", "black"},
+				{"BLACK ", "black"},
+				{"BlAck ", "black"},
+				{"Bl Ack ", "black"},
+		}),
+		in_, exp)
+{
+	auto in {in_};
+	BOOST_CHECK_NO_THROW(AssetFactory::normalizeColourName(in));
+	BOOST_CHECK_EQUAL(in, exp);
+}
+
+BOOST_AUTO_TEST_CASE(parseX11RGB)
+{
+	const auto parsedColours = AssetFactory::parseX11RGB(FIXTURESDIR "rgb.txt");
+	BOOST_REQUIRE_EQUAL(parsedColours.size(), 20);
+	BOOST_CHECK_EQUAL(parsedColours.at("cyan"), AssetFactory::Colour(0, 255, 255));
+	BOOST_CHECK_EQUAL(parsedColours.at("slategrey"), AssetFactory::Colour(112, 128, 144));
+	BOOST_CHECK_EQUAL(parsedColours.at("lightsteelblue1"), AssetFactory::Colour(202, 225, 255));
+}
-- 
cgit v1.2.3


From 98df33e0a52e086b68df2a62ce2f41cc6b67db63 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Thu, 2 Mar 2023 18:18:38 +0000
Subject: Parse colour values as they're read

---
 assetFactory/assetFactory.cpp   | 32 ++++++++++++++++--
 assetFactory/assetFactory.h     |  4 ++-
 assetFactory/modelFactoryMesh.h |  3 +-
 assetFactory/style.cpp          | 72 ++++++++++++++---------------------------
 assetFactory/style.h            | 18 +++++++++--
 assetFactory/use.cpp            |  3 +-
 test/test-assetFactory.cpp      | 14 ++++----
 7 files changed, 83 insertions(+), 63 deletions(-)

(limited to 'test/test-assetFactory.cpp')

diff --git a/assetFactory/assetFactory.cpp b/assetFactory/assetFactory.cpp
index 016f29e..70f5337 100644
--- a/assetFactory/assetFactory.cpp
+++ b/assetFactory/assetFactory.cpp
@@ -30,12 +30,12 @@ AssetFactory::parseX11RGB(const char * path)
 {
 	filesystem::FileStar rgb {path, "r"};
 	Colours out;
-	glm::u8vec3 colour;
+	Colour colour;
 	char inname[BUFSIZ];
-	while (fscanf(rgb, "%hhu %hhu %hhu %[^\n\r]s", &colour.r, &colour.g, &colour.b, inname) == 4) {
+	while (fscanf(rgb, "%f %f %f %[^\n\r]s", &colour.r, &colour.g, &colour.b, inname) == 4) {
 		std::string name {inname};
 		normalizeColourName(name);
-		out.emplace(std::move(name), colour);
+		out.emplace(std::move(name), colour / 255.f);
 	}
 	return out;
 }
@@ -49,6 +49,32 @@ AssetFactory::normalizeColourName(std::string & name)
 	};
 }
 
+AssetFactory::ColourAlpha
+AssetFactory::parseColour(std::string_view in) const
+{
+	if (in.empty()) {
+		throw std::runtime_error("Empty colour specification");
+	}
+	if (in[0] == '#') {
+		if (in.length() > 9 || in.length() % 2 == 0) {
+			throw std::runtime_error("Invalid hex colour specification");
+		}
+		ColourAlpha out {0, 0, 0, 1};
+		std::generate_n(&out.r, (in.length() - 1) / 2, [in = in.data() + 1]() mutable {
+			uint8_t channel;
+			std::from_chars(in, in + 2, channel, 16);
+			in += 2;
+			return static_cast<float>(channel) / 255.f;
+		});
+		return out;
+	}
+	if (auto mf = std::dynamic_pointer_cast<const AssetFactory>(Persistence::sharedObjects.at("assetFactory"))) {
+		if (const auto colour = mf->colours.find(in); colour != mf->colours.end()) {
+			return {colour->second, 1};
+		}
+	}
+	throw std::runtime_error("No such asset factory colour");
+}
 bool
 AssetFactory::persist(Persistence::PersistenceStore & store)
 {
diff --git a/assetFactory/assetFactory.h b/assetFactory/assetFactory.h
index 42082eb..2bd576b 100644
--- a/assetFactory/assetFactory.h
+++ b/assetFactory/assetFactory.h
@@ -22,11 +22,13 @@ class AssetFactory : public Persistence::Persistable {
 public:
 	using Shapes = std::map<std::string, Shape::Ptr, std::less<>>;
 	using Assets = std::map<std::string, Asset::Ptr, std::less<>>;
-	using Colour = glm::u8vec3;
+	using Colour = glm::vec3;
+	using ColourAlpha = glm::vec4;
 	using Colours = std::map<std::string, Colour, std::less<>>;
 
 	AssetFactory();
 	[[nodiscard]] static std::shared_ptr<AssetFactory> loadXML(const std::filesystem::path &);
+	[[nodiscard]] ColourAlpha parseColour(std::string_view) const;
 
 	Shapes shapes;
 	Assets assets;
diff --git a/assetFactory/modelFactoryMesh.h b/assetFactory/modelFactoryMesh.h
index b4f5254..258913b 100644
--- a/assetFactory/modelFactoryMesh.h
+++ b/assetFactory/modelFactoryMesh.h
@@ -5,6 +5,7 @@
 #include <OpenMesh/Core/Mesh/Traits.hh>
 #include <glm/geometric.hpp>
 #include <glm/vec3.hpp>
+#include <glm/vec4.hpp>
 
 namespace OpenMesh {
 	template<typename Scalar, int DIM> struct glmvec : public VectorT<Scalar, DIM> {
@@ -25,7 +26,7 @@ struct ModelFactoryTraits : public OpenMesh::DefaultTraits {
 	VertexAttributes(OpenMesh::Attributes::Normal | OpenMesh::Attributes::Status);
 	using Point = OpenMesh::glmvec<float, 3>;
 	using Normal = OpenMesh::glmvec<float, 3>;
-	using Color = OpenMesh::glmvec<float, 4>;
+	using Color = glm::vec4;
 };
 
 struct ModelFactoryMesh : public OpenMesh::PolyMesh_ArrayKernelT<ModelFactoryTraits> {
diff --git a/assetFactory/style.cpp b/assetFactory/style.cpp
index d2977a7..b2a2cf7 100644
--- a/assetFactory/style.cpp
+++ b/assetFactory/style.cpp
@@ -1,41 +1,16 @@
 #include "style.h"
 #include "assetFactory.h"
 
-ModelFactoryMesh::Color
-Style::parseColour(const std::string_view & in)
-{
-	if (in.empty()) {
-		throw std::runtime_error("Empty colour specification");
-	}
-	if (in[0] == '#') {
-		if (in.length() > 9 || in.length() % 2 == 0) {
-			throw std::runtime_error("Invalid hex colour specification");
-		}
-		ModelFactoryMesh::Color out {0, 0, 0, 1};
-		std::generate_n(out.begin(), (in.length() - 1) / 2, [in = in.data() + 1]() mutable {
-			uint8_t channel;
-			std::from_chars(in, in + 2, channel, 16);
-			in += 2;
-			return static_cast<float>(channel) / 256.F;
-		});
-		return out;
-	}
-	if (auto mf = std::dynamic_pointer_cast<const AssetFactory>(Persistence::sharedObjects.at("assetFactory"))) {
-		if (const auto colour = mf->colours.find(in); colour != mf->colours.end()) {
-			const auto out = glm::vec3 {colour->second} / 256.F;
-			return {out.r, out.g, out.b, 1.f};
-		}
-	}
-	throw std::runtime_error("No such asset factory colour");
-}
-
 void
 Style::applyStyle(ModelFactoryMesh & mesh, const StyleStack & parents, const Shape::CreatedFaces & faces) const
 {
-	if (const auto effectiveColour = getProperty(parents, &Style::colour); !effectiveColour.empty()) {
-		const auto parsedColour = parseColour(effectiveColour);
+	if (const auto effectiveColour = getProperty(parents, &Style::colour,
+				[](auto && style) {
+					return style->colour.a > 0;
+				});
+			effectiveColour.has_value()) {
 		for (const auto & face : faces) {
-			mesh.set_color(face.second, parsedColour);
+			mesh.set_color(face.second, effectiveColour->get());
 		}
 	}
 }
@@ -43,27 +18,30 @@ Style::applyStyle(ModelFactoryMesh & mesh, const StyleStack & parents, const Sha
 void
 Style::applyStyle(ModelFactoryMesh & mesh, const StyleStack & parents, const ModelFactoryMesh::FaceHandle & face) const
 {
-	if (const auto effectiveColour = getProperty(parents, &Style::colour); !effectiveColour.empty()) {
-		const auto parsedColour = parseColour(effectiveColour);
-		mesh.set_color(face, parsedColour);
-	}
-}
-
-std::string_view
-Style::getProperty(const StyleStack & parents, std::string Style::*member)
-{
-	if (const auto itr = std::find_if(parents.rbegin(), parents.rend(),
-				[&member](auto && s) {
-					return !(s->*member).empty();
+	if (const auto effectiveColour = getProperty(parents, &Style::colour,
+				[](auto && style) {
+					return style->colour.a > 0;
 				});
-			itr != parents.rend()) {
-		return (*itr)->*member;
+			effectiveColour.has_value()) {
+		mesh.set_color(face, effectiveColour->get());
 	}
-	return {};
 }
 
 bool
 Style::persist(Persistence::PersistenceStore & store)
 {
-	return STORE_MEMBER(colour);
+	struct ColourParser : public Persistence::SelectionV<ColourAlpha> {
+		using Persistence::SelectionV<ColourAlpha>::SelectionV;
+		using Persistence::SelectionV<ColourAlpha>::setValue;
+		void
+		setValue(std::string && str) override
+		{
+			if (auto mf
+					= std::dynamic_pointer_cast<const AssetFactory>(Persistence::sharedObjects.at("assetFactory"))) {
+				v = mf->parseColour(str);
+			}
+		}
+	};
+
+	return STORE_HELPER(colour, ColourParser);
 }
diff --git a/assetFactory/style.h b/assetFactory/style.h
index 0c7ad5a..e8fd012 100644
--- a/assetFactory/style.h
+++ b/assetFactory/style.h
@@ -3,19 +3,31 @@
 #include "modelFactoryMesh.h"
 #include "persistence.h"
 #include "shape.h"
+#include <optional>
 #include <string>
+#include <utility>
 
 class Style {
 public:
 	using StyleStack = std::vector<const Style *>;
+	using Colour = glm::vec3;
+	using ColourAlpha = glm::vec4;
 
-	static ModelFactoryMesh::Color parseColour(const std::string_view &);
 	void applyStyle(ModelFactoryMesh &, const StyleStack & parents, const Shape::CreatedFaces &) const;
 	void applyStyle(ModelFactoryMesh &, const StyleStack & parents, const ModelFactoryMesh::FaceHandle &) const;
 
-	static std::string_view getProperty(const StyleStack & parents, std::string Style::*member);
+	template<typename T>
+	static std::optional<std::reference_wrapper<const T>>
+	getProperty(const StyleStack & parents, T Style::*member, auto && test)
+	{
+		if (const auto itr = std::find_if(parents.rbegin(), parents.rend(), std::forward<decltype(test)>(test));
+				itr != parents.rend()) {
+			return (*itr)->*member;
+		}
+		return {};
+	}
 
-	std::string colour;
+	ColourAlpha colour {};
 
 protected:
 	bool persist(Persistence::PersistenceStore & store);
diff --git a/assetFactory/use.cpp b/assetFactory/use.cpp
index a6fac5c..53fc9b9 100644
--- a/assetFactory/use.cpp
+++ b/assetFactory/use.cpp
@@ -18,7 +18,8 @@ struct Lookup : public Persistence::SelectionV<Shape::CPtr> {
 	void
 	setValue(std::string && str) override
 	{
-		if (auto mf = std::dynamic_pointer_cast<const AssetFactory>(Persistence::sharedObjects.at("assetFactory"))) {
+		if (auto mf = std::dynamic_pointer_cast<const AssetFactory>(
+					Persistence::sharedObjects.at("assetFactory"))) {
 			v = mf->shapes.at(str);
 		}
 	}
diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 89f6bf0..8feb831 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -76,7 +76,7 @@ BOOST_AUTO_TEST_CASE(brush47)
 			wheelCylinder->position = {0, 0, 0.571};
 			wheelCylinder->scale = {1.142, 1.142, 0.07};
 			wheelCylinder->rotation = {0, 0, half_pi};
-			wheelCylinder->colour = "#2C3539";
+			wheelCylinder->colour = assetFactory.parseColour("#2C3539");
 		}
 		assetFactory.shapes.emplace(wheel->id, wheel);
 	}
@@ -120,10 +120,10 @@ BOOST_AUTO_TEST_CASE(brush47)
 		bodyLower->type = assetFactory.shapes.at("cuboid");
 		bodyLower->position = {0, 0, 1.2};
 		bodyLower->scale = {2.69, 19.38, 1.5};
-		bodyLower->colour = "#1111DD";
+		bodyLower->colour = assetFactory.parseColour("#1111DD");
 		auto & bottom = bodyLower->faceControllers["bottom"];
 		bottom = std::make_unique<FaceController>();
-		bottom->colour = "#2C3539";
+		bottom->colour = assetFactory.parseColour("#2C3539");
 		auto & bodyUpper = bodyLower->faceControllers["top"];
 		bodyUpper = std::make_unique<FaceController>();
 		bodyUpper->type = "extrude";
@@ -140,7 +140,7 @@ BOOST_AUTO_TEST_CASE(brush47)
 			batteryBox->type = assetFactory.shapes.at("cuboid");
 			batteryBox->position = {0, 0, .2};
 			batteryBox->scale = {2.6, 4.5, 1};
-			batteryBox->colour = "#2C3539";
+			batteryBox->colour = assetFactory.parseColour("#2C3539");
 		}
 	}
 	std::transform(factoryMeshes.begin(), factoryMeshes.end(), std::back_inserter(meshes.objects),
@@ -206,7 +206,7 @@ BOOST_AUTO_TEST_CASE(parseX11RGB)
 {
 	const auto parsedColours = AssetFactory::parseX11RGB(FIXTURESDIR "rgb.txt");
 	BOOST_REQUIRE_EQUAL(parsedColours.size(), 20);
-	BOOST_CHECK_EQUAL(parsedColours.at("cyan"), AssetFactory::Colour(0, 255, 255));
-	BOOST_CHECK_EQUAL(parsedColours.at("slategrey"), AssetFactory::Colour(112, 128, 144));
-	BOOST_CHECK_EQUAL(parsedColours.at("lightsteelblue1"), AssetFactory::Colour(202, 225, 255));
+	BOOST_CHECK_CLOSE_VEC(parsedColours.at("cyan"), AssetFactory::Colour(0, 1, 1));
+	BOOST_CHECK_CLOSE_VEC(parsedColours.at("slategrey"), AssetFactory::Colour(0.44F, 0.5, 0.56F));
+	BOOST_CHECK_CLOSE_VEC(parsedColours.at("lightsteelblue1"), AssetFactory::Colour(0.79, 0.88, 1));
 }
-- 
cgit v1.2.3


From 54ddcd3da0916b6a46f5fcf3f33ff0fbffe375ce Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 4 Mar 2023 14:27:23 +0000
Subject: Support and load factory asset directly into a RailVehicleClass
 instance

---
 assetFactory/asset.cpp             |  3 +--
 assetFactory/asset.h               |  2 --
 game/vehicles/railVehicleClass.cpp |  9 +++++++++
 game/vehicles/railVehicleClass.h   |  8 +++++++-
 res/brush47.xml                    | 14 +++++++-------
 test/test-assetFactory.cpp         | 18 +++++++++---------
 6 files changed, 33 insertions(+), 21 deletions(-)

(limited to 'test/test-assetFactory.cpp')

diff --git a/assetFactory/asset.cpp b/assetFactory/asset.cpp
index 659a950..3ab2f1c 100644
--- a/assetFactory/asset.cpp
+++ b/assetFactory/asset.cpp
@@ -3,8 +3,7 @@
 bool
 Asset::persist(Persistence::PersistenceStore & store)
 {
-	return STORE_MEMBER(id) && STORE_MEMBER(name)
-			&& STORE_NAME_HELPER("mesh", meshes, Persistence::Appender<FactoryMesh::Collection>);
+	return STORE_MEMBER(id) && STORE_MEMBER(name);
 }
 
 Asset::MeshConstruct::MeshConstruct(Mesh::Ptr & m) :
diff --git a/assetFactory/asset.h b/assetFactory/asset.h
index 8dd1ecb..e3318e4 100644
--- a/assetFactory/asset.h
+++ b/assetFactory/asset.h
@@ -9,8 +9,6 @@ public:
 	std::string id;
 	std::string name;
 
-	FactoryMesh::Collection meshes;
-
 protected:
 	struct MeshConstruct : public Persistence::SelectionPtrBase<FactoryMesh::Ptr> {
 		using Persistence::SelectionPtrBase<FactoryMesh::Ptr>::setValue;
diff --git a/game/vehicles/railVehicleClass.cpp b/game/vehicles/railVehicleClass.cpp
index dff1416..7052396 100644
--- a/game/vehicles/railVehicleClass.cpp
+++ b/game/vehicles/railVehicleClass.cpp
@@ -39,6 +39,15 @@ RailVehicleClass::RailVehicleClass(std::unique_ptr<ObjParser> o, std::shared_ptr
 	bogies[1] = m.at("Bogie2");
 }
 
+RailVehicleClass::RailVehicleClass() { }
+
+bool
+RailVehicleClass::persist(Persistence::PersistenceStore & store)
+{
+	return STORE_TYPE && STORE_MEMBER(maxSpeed) && STORE_NAME_HELPER("bogie", bogies, Asset::MeshArrayConstruct)
+			&& STORE_HELPER(bodyMesh, Asset::MeshConstruct) && Asset::persist(store);
+}
+
 void
 RailVehicleClass::render(
 		const SceneShader & shader, const Location & location, const std::array<Location, 2> & bl) const
diff --git a/game/vehicles/railVehicleClass.h b/game/vehicles/railVehicleClass.h
index bd74ab9..c50dacc 100644
--- a/game/vehicles/railVehicleClass.h
+++ b/game/vehicles/railVehicleClass.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "assetFactory/asset.h"
 #include "gfx/models/mesh.h"
 #include <array>
 #include <memory>
@@ -11,9 +12,10 @@ class Texture;
 class ObjParser;
 class Location;
 
-class RailVehicleClass {
+class RailVehicleClass : public Asset {
 public:
 	explicit RailVehicleClass(const std::string & name);
+	RailVehicleClass();
 
 	void render(const SceneShader &, const Location &, const std::array<Location, 2> &) const;
 	void shadows(const ShadowMapper &, const Location &) const;
@@ -25,6 +27,10 @@ public:
 	float length;
 	float maxSpeed;
 
+protected:
+	friend Persistence::SelectionPtrBase<std::shared_ptr<RailVehicleClass>>;
+	bool persist(Persistence::PersistenceStore & store) override;
+
 private:
 	RailVehicleClass(std::unique_ptr<ObjParser> obj, std::shared_ptr<Texture>);
 	static float bogieOffset(ObjParser & o);
diff --git a/res/brush47.xml b/res/brush47.xml
index 477610c..796641a 100644
--- a/res/brush47.xml
+++ b/res/brush47.xml
@@ -12,8 +12,8 @@
     <use type="axel" position="0,2,0"/>
     <use type="axel" position="0,-2,0"/>
   </object>
-  <asset id="brush-47" name="Brush 47">
-    <mesh id="body" size="2.69,19.38,3.9">
+  <asset p.typeid="RailVehicleClass" id="brush-47" name="Brush 47">
+    <bodyMesh id="body" size="2.69,19.38,3.9">
       <use type="cuboid" position="0,0,1.2" scale="2.69,19.38,1.5" colour="#2c4f5a">
         <face id="bottom" colour="#2c3539"/>
         <face id="front" colour="goldenrod"/>
@@ -25,12 +25,12 @@
         </face>
       </use>
       <use type="cuboid" position="0,0,0.2" scale="2.6,4.5,1" colour="grey30"/>
-    </mesh>
-    <mesh id="bogie1">
+    </bodyMesh>
+    <bogie id="bogie1">
       <use type="bogie" position="0,6,0" colour="#413b3a"/>
-    </mesh>
-    <mesh id="bogie2">
+    </bogie>
+    <bogie id="bogie2">
       <use type="bogie" position="0,-6,0" rotation="0,3.14159,0" colour="#413b3a"/>
-    </mesh>
+    </bogie>
   </asset>
 </ilt>
diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 8feb831..9930714 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -8,6 +8,7 @@
 #include "assetFactory/assetFactory.h"
 #include "assetFactory/factoryMesh.h"
 #include "assetFactory/object.h"
+#include "game/vehicles/railVehicleClass.h"
 #include "gfx/gl/sceneRenderer.h"
 #include "lib/collection.hpp"
 #include "lib/location.hpp"
@@ -167,16 +168,15 @@ BOOST_AUTO_TEST_CASE(brush47xml)
 	BOOST_CHECK_EQUAL(1, mf->assets.size());
 	auto brush47 = mf->assets.at("brush-47");
 	BOOST_REQUIRE(brush47);
-	BOOST_CHECK_EQUAL(3, brush47->meshes.size());
-	auto body = brush47->meshes.at(0);
-	BOOST_REQUIRE(body);
-	BOOST_CHECK_EQUAL("body", body->id);
-	BOOST_CHECK_EQUAL(2, body->uses.size());
+	auto brush47rvc = std::dynamic_pointer_cast<RailVehicleClass>(brush47);
+	BOOST_REQUIRE(brush47rvc);
+	BOOST_REQUIRE(brush47rvc->bodyMesh);
+	BOOST_REQUIRE(brush47rvc->bogies.front());
+	BOOST_REQUIRE(brush47rvc->bogies.back());
 
-	std::transform(brush47->meshes.begin(), brush47->meshes.end(), std::back_inserter(meshes.objects),
-			[](const FactoryMesh::CPtr & factoryMesh) -> Mesh::Ptr {
-				return factoryMesh->createMesh();
-			});
+	meshes.objects.push_back(brush47rvc->bodyMesh);
+	meshes.objects.push_back(brush47rvc->bogies.front());
+	meshes.objects.push_back(brush47rvc->bogies.back());
 
 	render(20);
 }
-- 
cgit v1.2.3


From 73a8abf0762a113a04b05e6f1364aa0b961fa7f6 Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan@randomdan.homeip.net>
Date: Sat, 4 Mar 2023 15:48:53 +0000
Subject: Remove old hard coded asset factory test, run entirely from XML load
 and render a RailVehicle instance

---
 test/test-assetFactory.cpp | 99 ++++------------------------------------------
 1 file changed, 7 insertions(+), 92 deletions(-)

(limited to 'test/test-assetFactory.cpp')

diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 9930714..ae5a88a 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -6,10 +6,11 @@
 #include <boost/test/unit_test.hpp>
 
 #include "assetFactory/assetFactory.h"
-#include "assetFactory/factoryMesh.h"
 #include "assetFactory/object.h"
+#include "game/vehicles/railVehicle.h"
 #include "game/vehicles/railVehicleClass.h"
 #include "gfx/gl/sceneRenderer.h"
+#include "gfx/renderable.h"
 #include "lib/collection.hpp"
 #include "lib/location.hpp"
 #include "lib/stream_support.hpp"
@@ -34,7 +35,7 @@ public:
 	content(const SceneShader & shader) const override
 	{
 		shader.basic.use(Location {{0, 0, 0}, {0, 0, 0}});
-		meshes.apply(&Mesh::Draw);
+		objects.apply(&Renderable::render, shader);
 	}
 	void
 	lights(const SceneShader & shader) const override
@@ -51,7 +52,7 @@ public:
 	shadows(const ShadowMapper & mapper) const override
 	{
 		mapper.dynamicPoint.use(Location {{0, 0, 0}, {0, 0, 0}});
-		meshes.apply(&Mesh::Draw);
+		objects.apply(&Renderable::shadows, mapper);
 	}
 	void
 	render(float dist = 10.f)
@@ -59,98 +60,13 @@ public:
 		sceneRenderer.camera.setView({dist, dist, dist}, south + west + down);
 		sceneRenderer.render(*this);
 	}
-	Collection<const Mesh> meshes;
+	Collection<const Renderable> objects;
 
 private:
 	SceneRenderer sceneRenderer;
 };
 
 BOOST_FIXTURE_TEST_SUITE(m, FactoryFixture);
-BOOST_AUTO_TEST_CASE(brush47)
-{
-	AssetFactory assetFactory;
-	{
-		auto wheel = std::make_shared<Object>("wheel");
-		{
-			auto wheelCylinder = wheel->uses.emplace_back(std::make_shared<Use>());
-			wheelCylinder->type = assetFactory.shapes.at("cylinder");
-			wheelCylinder->position = {0, 0, 0.571};
-			wheelCylinder->scale = {1.142, 1.142, 0.07};
-			wheelCylinder->rotation = {0, 0, half_pi};
-			wheelCylinder->colour = assetFactory.parseColour("#2C3539");
-		}
-		assetFactory.shapes.emplace(wheel->id, wheel);
-	}
-	{
-		auto axel = std::make_shared<Object>("axel");
-		for (float x : {-1.f, 1.f}) {
-			auto wheel = axel->uses.emplace_back(std::make_shared<Use>());
-			wheel->type = assetFactory.shapes.at("wheel");
-			wheel->position = {x * 0.717f, 0, 0};
-			wheel->rotation = {0, x == 1.f ? pi : 0.f, 0};
-		}
-		assetFactory.shapes.emplace(axel->id, axel);
-	}
-	{
-		auto bogie = std::make_shared<Object>("bogie");
-		for (float y : {-2.f, 0.f, 2.f}) {
-			auto axel = bogie->uses.emplace_back(std::make_shared<Use>());
-			axel->type = assetFactory.shapes.at("axel");
-			axel->position = {0, y, 0};
-		}
-		assetFactory.shapes.emplace(bogie->id, bogie);
-	}
-	FactoryMesh::Collection factoryMeshes;
-	{
-		unsigned short b {0};
-		for (float y : {-6.f, 6.f}) {
-			auto bogie = factoryMeshes.emplace_back(std::make_shared<FactoryMesh>());
-			bogie->id = "bogie" + std::to_string(b);
-			auto bogieUse = bogie->uses.emplace_back(std::make_shared<Use>());
-			bogieUse->type = assetFactory.shapes.at("bogie");
-			bogieUse->position = {0, y, 0};
-			bogieUse->rotation = {0, b * pi, 0};
-			b++;
-		}
-	}
-	{
-		auto body = factoryMeshes.emplace_back(std::make_shared<FactoryMesh>());
-		body->id = "body";
-		body->size = {2.69f, 19.38f, 3.9f};
-		auto bodyLower = body->uses.emplace_back(std::make_shared<Use>());
-		bodyLower->type = assetFactory.shapes.at("cuboid");
-		bodyLower->position = {0, 0, 1.2};
-		bodyLower->scale = {2.69, 19.38, 1.5};
-		bodyLower->colour = assetFactory.parseColour("#1111DD");
-		auto & bottom = bodyLower->faceControllers["bottom"];
-		bottom = std::make_unique<FaceController>();
-		bottom->colour = assetFactory.parseColour("#2C3539");
-		auto & bodyUpper = bodyLower->faceControllers["top"];
-		bodyUpper = std::make_unique<FaceController>();
-		bodyUpper->type = "extrude";
-		bodyUpper->scale = {1, .95f, 1};
-		bodyUpper->position = {0, 0, 1.0};
-		auto & roof = bodyUpper->faceControllers["top"];
-		roof = std::make_unique<FaceController>();
-		roof->type = "extrude";
-		roof->scale = {.6f, .9f, 0};
-		roof->position = {0, 0, 0.2};
-		roof->smooth = true;
-		{
-			auto batteryBox = body->uses.emplace_back(std::make_shared<Use>());
-			batteryBox->type = assetFactory.shapes.at("cuboid");
-			batteryBox->position = {0, 0, .2};
-			batteryBox->scale = {2.6, 4.5, 1};
-			batteryBox->colour = assetFactory.parseColour("#2C3539");
-		}
-	}
-	std::transform(factoryMeshes.begin(), factoryMeshes.end(), std::back_inserter(meshes.objects),
-			[](const FactoryMesh::CPtr & factoryMesh) -> Mesh::Ptr {
-				return factoryMesh->createMesh();
-			});
-
-	render(20);
-}
 BOOST_AUTO_TEST_CASE(brush47xml)
 {
 	auto mf = AssetFactory::loadXML(RESDIR "/brush47.xml");
@@ -174,9 +90,8 @@ BOOST_AUTO_TEST_CASE(brush47xml)
 	BOOST_REQUIRE(brush47rvc->bogies.front());
 	BOOST_REQUIRE(brush47rvc->bogies.back());
 
-	meshes.objects.push_back(brush47rvc->bodyMesh);
-	meshes.objects.push_back(brush47rvc->bogies.front());
-	meshes.objects.push_back(brush47rvc->bogies.back());
+	auto railVehicle = std::make_shared<RailVehicle>(brush47rvc);
+	objects.objects.push_back(railVehicle);
 
 	render(20);
 }
-- 
cgit v1.2.3