Separate geographic data (GeoData) from its visual representation(s) (Terrain)

5 files changed, 198 insertions, 104 deletions

diff --git a/game/gamestate.h b/game/gamestate.h
index b8dfa61..536c420 100644
--- a/game/gamestate.h
+++ b/game/gamestate.h
@@ -2,9 +2,11 @@
 #define GAMESTATE_H
 
 #include <collection.hpp>
+#include <memory>
 #include <special_members.hpp>
 
 class WorldObject;
+class GeoData;
 
 class GameState {
 public:
@@ -14,6 +16,7 @@ public:
 	NO_COPY(GameState);
 
 	Collection<WorldObject> world;
+	std::shared_ptr<GeoData> geoData;
 };
 extern GameState * gameState;
 
diff --git a/game/geoData.cpp b/game/geoData.cpp
new file mode 100644
index 0000000..55c69a1
--- /dev/null
+++ b/game/geoData.cpp
@@ -0,0 +1,106 @@
+#include "geoData.h"
+#include "gfx/image.h"
+#include <algorithm>
+#include <cstddef>
+#include <maths.h>
+#include <random>
+#include <stb/stb_image.h>
+#include <stdexcept>
+
+GeoData::GeoData(Limits l, float s) :
+	limit {std::move(l)}, size {(limit.second - limit.first) + 1}, scale {s}, nodes {[this]() {
+		return (static_cast<std::size_t>(size.x * size.y));
+	}()}
+{
+}
+
+void
+GeoData::generateRandom()
+{
+	// We acknowledge this is terrible :)
+
+	// Add hills
+	std::mt19937 gen(std::random_device {}());
+	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);
+	for (int h = 0; h < 500;) {
+		const glm::ivec2 hpos {rxpos(gen), rypos(gen)};
+		const glm::ivec2 hsize {rsize(gen), rsize(gen)};
+		if (const auto lim1 = hpos - hsize; lim1.x > limit.first.x && lim1.y > limit.first.y) {
+			if (const auto lim2 = hpos + hsize; lim2.x < limit.second.x && lim2.y < limit.second.y) {
+				const auto height = rheight(gen);
+				const glm::ivec2 hsizesqrd {hsize.x * hsize.x, hsize.y * hsize.y};
+				for (auto y = lim1.y; y < lim2.y; y += 1) {
+					for (auto x = lim1.x; x < lim2.x; x += 1) {
+						const auto dist {hpos - glm::ivec2 {x, y}};
+						const glm::ivec2 distsqrd {dist.x * dist.x, dist.y * dist.y};
+						const auto out {rdiv(sq(x - hpos.x), sq(hsize.x)) + rdiv(sq(y - hpos.y), sq(hsize.y))};
+						if (out <= 1.0F) {
+							auto & node {nodes[at({x, y})]};
+							const auto m {1.F / (7.F * out - 8.F) + 1.F};
+							node.height += height * m;
+						}
+					}
+				}
+				h += 1;
+			}
+		}
+	}
+}
+
+void
+GeoData::loadFromImages(const std::filesystem::path & fileName, float scale_)
+{
+	const Image map {fileName.c_str(), STBI_grey};
+	size = {map.width, map.height};
+	limit = {{0, 0}, size - glm::uvec2 {1, 1}};
+	const auto points {size.x * size.y};
+	scale = scale_;
+	nodes.resize(points);
+
+	std::transform(map.data.data(), map.data.data() + points, nodes.begin(), [](auto d) {
+		return Node {(d * 0.1F) - 1.5F};
+	});
+}
+
+unsigned int
+GeoData::at(glm::ivec2 coord) const
+{
+	if (coord.x < limit.first.x || coord.x > limit.second.x || coord.y < limit.first.y || coord.y > limit.second.y) {
+		throw std::range_error {"Coordinates outside GeoData limits"};
+	}
+	const glm::uvec2 offset = coord - limit.first;
+	return offset.x + (offset.y * size.x);
+}
+
+unsigned int
+GeoData::at(int x, int y) const
+{
+	return at({x, y});
+}
+
+GeoData::Limits
+GeoData::getLimit() const
+{
+	return limit;
+}
+
+float
+GeoData::getScale() const
+{
+	return scale;
+}
+
+glm::uvec2
+GeoData::getSize() const
+{
+	return size;
+}
+
+std::span<const GeoData::Node>
+GeoData::getNodes() const
+{
+	return nodes;
+}
diff --git a/game/geoData.h b/game/geoData.h
new file mode 100644
index 0000000..39c149c
--- /dev/null
+++ b/game/geoData.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <filesystem>
+#include <glm/glm.hpp>
+#include <span>
+#include <utility>
+#include <vector>
+
+class GeoData {
+public:
+	struct Node {
+		float height {-1.5F};
+	};
+
+	using Limits = std::pair<glm::ivec2, glm::ivec2>;
+
+	GeoData() = default;
+	explicit GeoData(Limits limit, float scale = 10.F);
+
+	void generateRandom();
+	void loadFromImages(const std::filesystem::path &, float scale);
+
+	[[nodiscard]] unsigned int at(glm::ivec2) const;
+	[[nodiscard]] unsigned int at(int x, int y) const;
+
+	[[nodiscard]] Limits getLimit() const;
+	[[nodiscard]] glm::uvec2 getSize() const;
+	[[nodiscard]] float getScale() const;
+	[[nodiscard]] std::span<const Node> getNodes() const;
+
+protected:
+	Limits limit {}; // Base grid limits first(x,y) -> second(x,y)
+	glm::uvec2 size {};
+	float scale {1};
+	std::vector<Node> nodes;
+};
diff --git a/game/terrain.cpp b/game/terrain.cpp
index 3089f3a..10a6215 100644
--- a/game/terrain.cpp
+++ b/game/terrain.cpp
@@ -1,5 +1,8 @@
 #include "terrain.h"
+#include "game/geoData.h"
 #include "gfx/models/texture.h"
+#include <algorithm>
+#include <array>
 #include <cache.h>
 #include <cstddef>
 #include <filesystem>
@@ -8,116 +11,66 @@
 #include <gfx/models/mesh.h>
 #include <gfx/models/vertex.hpp>
 #include <glm/glm.hpp>
+#include <iterator>
 #include <location.hpp>
 #include <maths.h>
-#include <random>
-#include <stb/stb_image.h>
+#include <utility>
+#include <vector>
 
-Terrain::Terrain() : grass {Texture::cachedTexture.get("grass.png")}, water {Texture::cachedTexture.get("water.png")}
+Terrain::Terrain(std::shared_ptr<GeoData> gd) :
+	geoData {std::move(gd)}, grass {Texture::cachedTexture.get("grass.png")}, water {Texture::cachedTexture.get(
+																					  "water.png")}
 {
-	constexpr auto size {241}; // Vertices
-	constexpr auto offset {(size - 1) / 2};
-	constexpr auto verticesCount = size * size;
-	constexpr auto resolution = 10; // Grid size
-
-	std::vector<Vertex> vertices;
-	vertices.reserve(verticesCount + 4);
-	vertices.resize(verticesCount, {{}, {}, {}});
-
-	// Initial coordinates
-	for (auto y = 0U; y < size; y += 1) {
-		for (auto x = 0U; x < size; x += 1) {
-			auto & vertex = vertices[x + (y * size)];
-			vertex.pos
-					= {resolution * (static_cast<int>(x) - offset), resolution * (static_cast<int>(y) - offset), -1.5};
-			vertex.normal = up;
-			vertex.texCoord = {x, y};
-		}
-	}
-	// Add hills
-	std::mt19937 gen(std::random_device {}());
-	std::uniform_int_distribution<> rpos(2, size - 2);
-	std::uniform_int_distribution<> rsize(10, 30);
-	std::uniform_real_distribution<float> rheight(1, 3);
-	for (int h = 0; h < 500;) {
-		const glm::ivec2 hpos {rpos(gen), rpos(gen)};
-		const glm::ivec2 hsize {rsize(gen), rsize(gen)};
-		if (const auto lim1 = hpos - hsize; lim1.x > 0 && lim1.y > 0) {
-			if (const auto lim2 = hpos + hsize; lim2.x < size && lim2.y < size) {
-				const auto height = rheight(gen);
-				const glm::ivec2 hsizesqrd {hsize.x * hsize.x, hsize.y * hsize.y};
-				for (auto y = lim1.y; y < lim2.y; y += 1) {
-					for (auto x = lim1.x; x < lim2.x; x += 1) {
-						const auto dist {hpos - glm::ivec2 {x, y}};
-						const glm::ivec2 distsqrd {dist.x * dist.x, dist.y * dist.y};
-						const auto out {rdiv(sq(x - hpos.x), sq(hsize.x)) + rdiv(sq(y - hpos.y), sq(hsize.y))};
-						if (out <= 1.0F) {
-							auto & vertex
-									= vertices[static_cast<std::size_t>(x) + (static_cast<std::size_t>(y) * size)];
-							const auto m {1.F / (7.F * out - 8.F) + 1.F};
-							vertex.pos.z += height * m;
-						}
-					}
-				}
-				h += 1;
-			}
-		}
-	}
-	finish(size, size, vertices);
+	generateMeshes();
 }
 
-Terrain::Terrain(const std::string & fileName) :
-	grass {Texture::cachedTexture.get("grass.png")}, water {Texture::cachedTexture.get("water.png")}
+void
+Terrain::generateMeshes()
 {
-	constexpr auto resolution {100};
-
-	const Image map {fileName.c_str(), STBI_grey};
-
-	std::vector<Vertex> vertices;
-	vertices.reserve((map.width * map.height) + 4);
+	std::vector<unsigned int> indices;
+	const auto isize = geoData->getSize() - glm::uvec2 {1, 1};
+	indices.reserve(static_cast<std::size_t>(isize.x * isize.y) * 6);
 
-	for (auto y = 0U; y < map.height; y += 1) {
-		for (auto x = 0U; x < map.width; x += 1) {
-			vertices.emplace_back(glm::vec3 {resolution * (x - (map.width / 2)), resolution * (y - (map.height / 2)),
-										  (static_cast<float>(map.data[x + (y * map.width)]) * 0.1F) - 1.5F},
-					glm::vec2 {(x % 2) / 2.01, (y % 2) / 2.01}, up);
+	const auto limit = geoData->getLimit();
+	//  Indices
+	constexpr std::array<glm::ivec2, 6> indices_offsets {{
+			{0, 0},
+			{1, 0},
+			{1, 1},
+			{0, 0},
+			{1, 1},
+			{0, 1},
+	}};
+	for (auto y = limit.first.y; y < limit.second.y; y += 1) {
+		for (auto x = limit.first.x; x < limit.second.x; x += 1) {
+			std::transform(indices_offsets.begin(), indices_offsets.end(), std::back_inserter(indices),
+					[this, x, y](const auto off) {
+						return geoData->at(x + off.x, y + off.y);
+					});
 		}
 	}
 
-	finish(map.width, map.height, vertices);
-}
-
-void
-Terrain::finish(unsigned int width, unsigned int height, std::vector<Vertex> & vertices)
-{
-	const auto tilesCount = (width - 1) * (height - 1);
-	const auto trianglesCount = tilesCount * 2;
-	const auto indicesCount = trianglesCount * 3;
-	std::vector<unsigned int> indices;
-	indices.reserve(indicesCount + 6);
-	// Indices
-	for (auto y = 0U; y < height - 1; y += 1) {
-		for (auto x = 0U; x < width - 1; x += 1) {
-			indices.push_back(x + (y * width));
-			indices.push_back((x + 1) + (y * width));
-			indices.push_back((x + 1) + ((y + 1) * width));
-			indices.push_back(x + (y * width));
-			indices.push_back((x + 1) + ((y + 1) * width));
-			indices.push_back(x + ((y + 1) * width));
+	const auto nodes = geoData->getNodes();
+	const auto scale = geoData->getScale();
+	std::vector<Vertex> vertices;
+	vertices.reserve(nodes.size());
+	// Positions
+	for (auto y = limit.first.y; y <= limit.second.y; y += 1) {
+		for (auto x = limit.first.x; x <= limit.second.x; x += 1) {
+			const glm::vec2 xy {x, y};
+			vertices.emplace_back((xy * scale) ^ nodes[geoData->at(x, y)].height, xy, ::up);
 		}
 	}
 	// Normals
-	auto v = [&vertices](unsigned int width, unsigned int x, unsigned int y) -> Vertex & {
-		return vertices[x + (y * width)];
-	};
-
-	for (auto y = 1U; y < height - 1; y += 1) {
-		for (auto x = 1U; x < width - 1; x += 1) {
-			const auto a = v(width, x - 1, y).pos;
-			const auto b = v(width, x, y - 1).pos;
-			const auto c = v(width, x + 1, y).pos;
-			const auto d = v(width, x, y + 1).pos;
-			v(width, x, y).normal = -glm::normalize(glm::cross(b - d, a - c));
+	const glm::uvec2 size = geoData->getSize();
+	for (auto y = limit.first.y + 1; y < limit.second.y; y += 1) {
+		for (auto x = limit.first.x + 1; x < limit.second.x; x += 1) {
+			const auto n {geoData->at(x, y)};
+			const auto a = vertices[n - 1].pos;
+			const auto b = vertices[n - size.x].pos;
+			const auto c = vertices[n + 1].pos;
+			const auto d = vertices[n + size.x].pos;
+			vertices[n].normal = -glm::normalize(glm::cross(b - d, a - c));
 		}
 	}
 	meshes.create<Mesh>(vertices, indices);
diff --git a/game/terrain.h b/game/terrain.h
index c32f092..4775dff 100644
--- a/game/terrain.h
+++ b/game/terrain.h
@@ -7,17 +7,14 @@
 #include <gfx/models/mesh.h>
 #include <gfx/renderable.h>
 #include <memory>
-#include <string>
-#include <vector>
 
 class Shader;
 class Texture;
-class Vertex;
+class GeoData;
 
 class Terrain : public WorldObject, public Renderable {
 public:
-	Terrain();
-	explicit Terrain(const std::string &);
+	explicit Terrain(std::shared_ptr<GeoData>);
 
 	void render(const Shader & shader) const override;
 
@@ -25,10 +22,9 @@ public:
 	float waveCycle {0.F};
 
 private:
-	static constexpr unsigned int NUM_BUFFERS {4};
-
-	void finish(unsigned int width, unsigned int height, std::vector<Vertex> &);
+	void generateMeshes();
 
+	std::shared_ptr<GeoData> geoData;
 	Collection<Mesh, false> meshes;
 	std::shared_ptr<Texture> grass, water;
 };