Use texture atlas for asset factory

8 files changed, 29 insertions, 28 deletions

diff --git a/assetFactory/asset.h b/assetFactory/asset.h
index 30f40cd..dba4974 100644
--- a/assetFactory/asset.h
+++ b/assetFactory/asset.h
@@ -4,11 +4,11 @@
 #include "persistence.h"
 #include <stdTypeDefs.hpp>
 
-class Texture;
+class TextureAtlas;
 
 class Asset : public Persistence::Persistable, public StdTypeDefs<Asset> {
 public:
-	using TexturePtr = std::shared_ptr<Texture>;
+	using TexturePtr = std::shared_ptr<TextureAtlas>;
 
 	std::string id;
 	std::string name;
diff --git a/assetFactory/assetFactory.cpp b/assetFactory/assetFactory.cpp
index 917edfe..46b4642 100644
--- a/assetFactory/assetFactory.cpp
+++ b/assetFactory/assetFactory.cpp
@@ -80,17 +80,11 @@ AssetFactory::parseColour(std::string_view in) const
 	throw std::runtime_error("No such asset factory colour");
 }
 
-AssetFactory::TextureFragmentCoords
-AssetFactory::getTextureCoords(std::string_view id) const
+GLuint
+AssetFactory::getMaterialIndex(std::string_view id) const
 {
 	createTexutre();
-	const auto & fragmentUV = textureFragmentPositions.at(id);
-	return {
-			fragmentUV.xy(),
-			fragmentUV.zy(),
-			fragmentUV.zw(),
-			fragmentUV.xw(),
-	};
+	return textureFragmentPositions.at(id);
 }
 
 Asset::TexturePtr
@@ -103,7 +97,7 @@ AssetFactory::getTexture() const
 void
 AssetFactory::createTexutre() const
 {
-	if (!textureFragments.empty() && (!texture || textureFragmentPositions.empty())) {
+	if (!textureFragments.empty() && !texture) {
 		// * layout images
 		std::vector<TexturePacker::Image> imageSizes;
 		std::transform(
@@ -112,18 +106,14 @@ AssetFactory::createTexutre() const
 				});
 		const auto [layout, outSize] = TexturePacker {imageSizes}.pack();
 		// * create texture
-		texture = std::make_shared<Texture>(outSize.x, outSize.y, TextureOptions {.wrap = GL_CLAMP_TO_EDGE});
+		texture = std::make_shared<TextureAtlas>(outSize.x, outSize.y, layout.size());
 		std::transform(textureFragments.begin(), textureFragments.end(),
 				std::inserter(textureFragmentPositions, textureFragmentPositions.end()),
-				[position = layout.begin(), size = imageSizes.begin(), outSize = glm::vec2 {outSize}](
-						const auto & tf) mutable {
-					const auto positionFraction = glm::vec4 {*position, *position + *size} / outSize.xyxy();
-					glTexSubImage2D(GL_TEXTURE_2D, 0, static_cast<GLint>(position->x), static_cast<GLint>(position->y),
-							static_cast<GLint>(size->x), static_cast<GLint>(size->y), GL_RGBA, GL_UNSIGNED_BYTE,
-							tf.second->image->data.data());
+				[position = layout.begin(), size = imageSizes.begin(), this](const auto & tf) mutable {
+					const auto m = texture->add(*position, *size, tf.second->image->data.data());
 					position++;
 					size++;
-					return decltype(textureFragmentPositions)::value_type {tf.first, positionFraction};
+					return decltype(textureFragmentPositions)::value_type {tf.first, m};
 				});
 	}
 }
diff --git a/assetFactory/assetFactory.h b/assetFactory/assetFactory.h
index 7843d44..9e5d205 100644
--- a/assetFactory/assetFactory.h
+++ b/assetFactory/assetFactory.h
@@ -23,7 +23,7 @@ public:
 	AssetFactory();
 	[[nodiscard]] static std::shared_ptr<AssetFactory> loadXML(const std::filesystem::path &);
 	[[nodiscard]] ColourAlpha parseColour(std::string_view) const;
-	[[nodiscard]] TextureFragmentCoords getTextureCoords(std::string_view) const;
+	[[nodiscard]] GLuint getMaterialIndex(std::string_view) const;
 	[[nodiscard]] Asset::TexturePtr getTexture() const;
 
 	Shapes shapes;
@@ -42,5 +42,5 @@ private:
 	void createTexutre() const;
 
 	mutable Asset::TexturePtr texture;
-	mutable std::map<std::string_view, glm::vec4, std::less<>> textureFragmentPositions;
+	mutable std::map<std::string_view, GLuint, std::less<>> textureFragmentPositions;
 };
diff --git a/assetFactory/assimp.cpp b/assetFactory/assimp.cpp
index 0c6cb86..dd82105 100644
--- a/assetFactory/assimp.cpp
+++ b/assetFactory/assimp.cpp
@@ -64,11 +64,11 @@ public:
 		};
 		const auto & m = *scene->mMaterials[amesh->mMaterialIndex];
 
-		AssetFactory::TextureFragmentCoords tfc;
+		GLuint material {};
 		if (auto mf = Persistence::ParseBase::getShared<AssetFactory>("assetFactory")) {
 			aiString path;
 			m.Get(AI_MATKEY_TEXTURE_DIFFUSE(0), path);
-			tfc = mf->getTextureCoords(path.C_Str());
+			material = mf->getMaterialIndex(path.C_Str());
 		}
 
 		for (const auto & f : AIRANGE(amesh, Faces)) {
@@ -79,8 +79,8 @@ public:
 			if (amesh->HasTextureCoords(0)) {
 				for (auto idx = f.mIndices; const auto fheh : mesh.fh_range(fh)) {
 					const auto ouv = !amesh->mTextureCoords[0][*idx++];
-					const auto uv = glm::mix(tfc[0], tfc[2], ouv);
-					mesh.set_texcoord2D(fheh, uv);
+					mesh.set_texcoord2D(fheh, ouv);
+					mesh.property(mesh.materialFaceProperty, fh) = material;
 				}
 			}
 		}
diff --git a/assetFactory/factoryMesh.cpp b/assetFactory/factoryMesh.cpp
index 4922936..f7bc7c8 100644
--- a/assetFactory/factoryMesh.cpp
+++ b/assetFactory/factoryMesh.cpp
@@ -18,6 +18,7 @@ FactoryMesh::createMesh() const
 		for (const auto & face : mesh.faces()) {
 			const auto & smooth = mesh.property(mesh.smoothFaceProperty, face);
 			const auto & colour = mesh.color(face);
+			const auto & material = mesh.property(mesh.materialFaceProperty, face);
 
 			std::vector<unsigned int> faceIndices;
 			for (const auto & heh : mesh.fh_range(face)) {
@@ -26,7 +27,7 @@ FactoryMesh::createMesh() const
 				const auto & point = mesh.point(vertex);
 				const auto & normal = smooth ? mesh.property(mesh.vertex_normals_pph(), vertex)
 											 : mesh.property(mesh.face_normals_pph(), face);
-				Vertex outVertex {point, textureUV, normal, colour};
+				Vertex outVertex {point, 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/assetFactory/modelFactoryMesh.cpp b/assetFactory/modelFactoryMesh.cpp
index e640502..3d4b5f3 100644
--- a/assetFactory/modelFactoryMesh.cpp
+++ b/assetFactory/modelFactoryMesh.cpp
@@ -3,6 +3,7 @@
 ModelFactoryMesh::ModelFactoryMesh()
 {
 	add_property(smoothFaceProperty);
+	add_property(materialFaceProperty);
 	add_property(nameFaceProperty);
 	add_property(nameAdjFaceProperty);
 }
diff --git a/assetFactory/modelFactoryMesh.h b/assetFactory/modelFactoryMesh.h
index 8ac2edd..4eac7ee 100644
--- a/assetFactory/modelFactoryMesh.h
+++ b/assetFactory/modelFactoryMesh.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "modelFactoryMesh_fwd.h"
+#include <GL/glew.h>
 #include <OpenMesh/Core/Mesh/PolyMesh_ArrayKernelT.hh>
 #include <OpenMesh/Core/Mesh/Traits.hh>
 #include <glm/geometric.hpp>
@@ -47,6 +48,7 @@ struct ModelFactoryMesh : public OpenMesh::PolyMesh_ArrayKernelT<ModelFactoryTra
 	ModelFactoryMesh();
 
 	OpenMesh::FPropHandleT<bool> smoothFaceProperty;
+	OpenMesh::FPropHandleT<GLuint> materialFaceProperty;
 	OpenMesh::FPropHandleT<std::string> nameFaceProperty;
 	OpenMesh::HPropHandleT<std::string> nameAdjFaceProperty;
 
diff --git a/assetFactory/style.cpp b/assetFactory/style.cpp
index 12346a6..ea67fc2 100644
--- a/assetFactory/style.cpp
+++ b/assetFactory/style.cpp
@@ -30,7 +30,14 @@ Style::applyStyle(
 	else {
 		mesh.set_color(face, {});
 		if (auto mf = Persistence::ParseBase::getShared<const AssetFactory>("assetFactory")) {
-			auto coords = mf->getTextureCoords(texture);
+			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},
+			}};
 			auto coord = coords.begin();
 			// Wild assumption that face is a quad and the texture should apply linearly
 			for (const auto & heh : mesh.fh_range(face)) {