Refactor logic from Noise to NoiseCollection

Application/Chunk.cpp

@@ -16,7 +16,7 @@ constexpr std::array<std::array<Scop::Vec2ui, 3>, BlocksCount> BLOCKS_TO_ATLAS =
 	std::array<Scop::Vec2ui, 3>{ Scop::Vec2ui{ 2, 0 }, Scop::Vec2ui{ 0, 0 }, Scop::Vec2ui{ 3, 0 } }, // Grass
 	std::array<Scop::Vec2ui, 3>{ Scop::Vec2ui{ 0, 1 }, Scop::Vec2ui{ 0, 1 }, Scop::Vec2ui{ 0, 1 } }, // Sand
 	std::array<Scop::Vec2ui, 3>{ Scop::Vec2ui{ 2, 1 }, Scop::Vec2ui{ 2, 1 }, Scop::Vec2ui{ 2, 1 } }, // Snow
-	std::array<Scop::Vec2ui, 3>{ Scop::Vec2ui{ 3, 1 }, Scop::Vec2ui{ 3, 1 }, Scop::Vec2ui{ 3, 1 } }, // SnowyGrass
+	std::array<Scop::Vec2ui, 3>{ Scop::Vec2ui{ 2, 1 }, Scop::Vec2ui{ 0, 0 }, Scop::Vec2ui{ 3, 1 } }, // SnowyGrass
 	std::array<Scop::Vec2ui, 3>{ Scop::Vec2ui{ 0, 2 }, Scop::Vec2ui{ 0, 2 }, Scop::Vec2ui{ 0, 2 } }, // Cactus
 };
 

Application/Noise.cpp

@@ -166,32 +166,3 @@ const int Noise::ApplyPerlin2DParameters(float x, float y) noexcept // Wrapper t
 	return static_cast<int>(normalized * HEIGHT_COEFF);
 }
 
-[[nodiscard]] std::array<std::uint32_t, CHUNK_SIZE.y> Noise::GetHeight(Scop::Vec2i pos)
-{
-	std::array<std::uint32_t, CHUNK_SIZE.y> data;
-	std::memset(data.data(), static_cast<std::uint32_t>(BlockType::Air), data.size() * sizeof(std::uint32_t));
-
-	const std::uint32_t height = Perlin2D(pos.x, pos.y);
-
-	for(std::uint32_t y = 0; y < std::min(height, CHUNK_SIZE.y); y++)
-	{
-		// const std::uint32_t value = Perlin3D(pos.x, y, pos.y);
-		if(y > std::min(height, CHUNK_SIZE.y) - 2)
-		{
-			if(height <= 23)
-				data[y] = static_cast<std::uint32_t>(BlockType::Sand);
-			else if(height < 140)
-				data[y] = static_cast<std::uint32_t>(BlockType::Grass);
-			else
-				data[y] = static_cast<std::uint32_t>(BlockType::Snow);
-		}
-		else
-			data[y] = static_cast<std::uint32_t>(BlockType::Stone);
-	}
-	for(std::uint32_t y = 0; y < WATER_LEVEL; y++)
-	{
-		if(data[y] == static_cast<std::uint32_t>(BlockType::Air))
-			data[y] = static_cast<std::uint32_t>(BlockType::Water);
-	}
-	return data;
-}

Application/Noise.h

@@ -9,14 +9,12 @@
 
 constexpr float HEIGHT_COEFF = 255.0f;
 constexpr std::uint32_t NOISE_SIZE = 512;
-constexpr std::uint32_t WATER_LEVEL = 20;
 
 class Noise
 {
 	public:
 		Noise(const std::uint32_t seed, float frequency, float amplitude, int octaves, float lacunarity, float persistance, int redistribution, float compensatory_factor);
 
-		[[nodiscard]] std::array<std::uint32_t, CHUNK_SIZE.y> GetHeight(Scop::Vec2i pos);
 		[[nodiscard]] const int Perlin2D(int x, int y) noexcept;
 		[[nodiscard]] const int Perlin3D(int x, int y, int z) noexcept;
 

Application/NoiseCollection.cpp

@@ -1,4 +1,6 @@
+#include "Block.h"
 #include "Chunk.h"
+#include "Maths/Constants.h"
 #include "Maths/Vec2.h"
 #include <NoiseCollection.h>
 #include <Noise.h>
@@ -16,5 +18,46 @@ Noise* NoiseCollection::GetNoise(const std::string& key) const
 
 const std::array<std::uint32_t, CHUNK_SIZE.y> NoiseCollection::GetBlocks(Scop::Vec2i pos)
 {
-	return m_collection["terrain"]->GetHeight(pos);	
+	const std::uint32_t height = m_collection["terrain"]->Perlin2D(pos.x, pos.y) + ARTIFICIAL_ELEVATION;
+	std::array<std::uint32_t, CHUNK_SIZE.y> data;
+
+	std::memset(data.data(), static_cast<std::uint32_t>(BlockType::Air), data.size() * sizeof(std::uint32_t));
+
+	for(std::uint32_t y = 0; y < std::min(height, CHUNK_SIZE.y); y++)
+	{
+		// const std::uint32_t value = Perlin3D(pos.x, y, pos.y);
+		if(y > std::min(height, CHUNK_SIZE.y) - 2)
+		{
+			if(height <= 23 + ARTIFICIAL_ELEVATION)
+				data[y] = static_cast<std::uint32_t>(BlockType::Sand);
+			else if(height < 125 + ARTIFICIAL_ELEVATION)
+				data[y] = static_cast<std::uint32_t>(BlockType::Grass);
+			else if (height < 132 + ARTIFICIAL_ELEVATION)
+			{
+				float weight = sin(2 * (pos.x * pos.y)) + sin(Scop::Pi<float>() * (pos.x * pos.y));
+				if (weight > 0.0f)
+					data[y] = static_cast<std::uint32_t>(BlockType::Grass);
+				else
+					data[y] = static_cast<std::uint32_t>(BlockType::SnowyGrass);
+			}
+			else if (height < 140 + ARTIFICIAL_ELEVATION)
+			{
+				float weight = sin(2 * (pos.x * pos.y)) + sin(Scop::Pi<float>() * (pos.x * pos.y));
+				if (weight > 0.0f)
+					data[y] = static_cast<std::uint32_t>(BlockType::Snow);
+				else
+					data[y] = static_cast<std::uint32_t>(BlockType::SnowyGrass);
+			}
+			else
+				data[y] = static_cast<std::uint32_t>(BlockType::Snow);
+		}
+		else
+			data[y] = static_cast<std::uint32_t>(BlockType::Stone);
+	}
+	for(std::uint32_t y = 0; y < ARTIFICIAL_ELEVATION + WATER_LEVEL; y++)
+	{
+		if(data[y] == static_cast<std::uint32_t>(BlockType::Air))
+			data[y] = static_cast<std::uint32_t>(BlockType::Water);
+	}
+	return data;
 }

Application/NoiseCollection.h

@@ -6,6 +6,10 @@
 #include <memory>
 #include <unordered_map>
 
+constexpr std::uint32_t ARTIFICIAL_ELEVATION = 40;
+
+constexpr std::uint32_t WATER_LEVEL = 20;
+
 class NoiseCollection
 {
 	public:
@@ -20,13 +24,20 @@ class NoiseCollection
 																	4,
 																	1.2f
 																	));
-			//m_collection.emplace("caves", std::make_unique<Noise>(seed)); // TODO !!!!!!
+			m_collection.emplace("caves", std::make_unique<Noise>(seed,
+																	0.02f,
+																	1.0f,
+																	5,
+																	2.0f,
+																	0.5f,
+																	3,
+																	1.0f
+																	)); // TODO !!!!!!
 		}
 
 		Noise* GetNoise(const std::string& key) const;
 
 		inline void AddNoise(std::string key, std::unique_ptr<Noise> noise) { m_collection.emplace(std::move(key), std::move(noise)); }
-		[[nodiscard]] inline std::array<std::uint32_t, CHUNK_SIZE.y> GetBlocks(Scop::Vec2i pos) const { return m_collection.at("terrain")->GetHeight(pos); }
 		const std::array<std::uint32_t, CHUNK_SIZE.y> GetBlocks(Scop::Vec2i pos);
 		~NoiseCollection() = default;