perlin noise worldgen

CMakeLists.txt

@@ -16,7 +16,7 @@ else()
 	message(FATAL_ERROR "CMAKE_BUILD_TYPE must be Debug or Release.")
 endif()
 
-include_directories("${PROJECT_SOURCE_DIR}/libswan/include")
+include_directories("${PROJECT_SOURCE_DIR}/libswan/include" "${PROJECT_SOURCE_DIR}/third_party")
 
 add_subdirectory(libswan)
 add_subdirectory(core.mod)

core.mod/src/WGDefault.cc

@@ -1,15 +1,19 @@
 #include "WGDefault.h"
 
 void WGDefault::genChunk(Swan::WorldPlane &plane, Swan::Chunk &chunk) {
+	int height = perlin_.octaveNoise0_1(chunk.pos_.x_ / (64.0 / 16), 8) * 10;
+	int depth = perlin_.octaveNoise0_1(chunk.pos_.x_ / (64.0 / 9), 5) * 10 + 10;
+
 	for (int cx = 0; cx < Swan::CHUNK_WIDTH; ++cx) {
 		for (int cy = 0; cy < Swan::CHUNK_HEIGHT; ++cy) {
 			Swan::TilePos tpos = Swan::TilePos(cx, cy) + Swan::TilePos(
 					chunk.pos_.x_ * Swan::CHUNK_WIDTH, chunk.pos_.y_ * Swan::CHUNK_HEIGHT);
-			if (tpos.y_ == 3)
+
+			if (tpos.y_ == height)
 				chunk.tiles_[cx][cy] = tGrass_;
-			else if (tpos.y_ > 3 && tpos.y_ <= 5)
+			else if (tpos.y_ > height && tpos.y_ <= depth)
 				chunk.tiles_[cx][cy] = tDirt_;
-			else if (tpos.y_ > 5)
+			else if (tpos.y_ > depth)
 				chunk.tiles_[cx][cy] = tStone_;
 			else
 				chunk.tiles_[cx][cy] = tAir_;

core.mod/src/WGDefault.h

@@ -2,6 +2,8 @@
 
 #include <swan/swan.h>
 
+#include <PerlinNoise/PerlinNoise.hpp>
+
 class WGDefault: public Swan::WorldGen {
 public:
 	class Factory: public Swan::WorldGen::Factory {
@@ -9,12 +11,14 @@ public:
 		WorldGen *create(Swan::TileMap &tmap) { return new WGDefault(tmap); }
 	};
 
-	Swan::Tile::ID tGrass_, tDirt_, tStone_, tAir_;
-
 	WGDefault(Swan::TileMap &tmap):
 		tGrass_(tmap.getID("core::grass")), tDirt_(tmap.getID("core::dirt")),
 		tStone_(tmap.getID("core::stone")), tAir_(tmap.getID("core::air")) {}
 
 	void genChunk(Swan::WorldPlane &plane, Swan::Chunk &chunk) override;
 	Swan::Entity &spawnPlayer(Swan::WorldPlane &plane) override;
+
+private:
+	Swan::Tile::ID tGrass_, tDirt_, tStone_, tAir_;
+	siv::PerlinNoise perlin_ = siv::PerlinNoise(100);
 };

third_party/PerlinNoise/PerlinNoise.hpp

@@ -0,0 +1,219 @@
+//----------------------------------------------------------------------------------------
+//
+//	siv::PerlinNoise
+//	Perlin noise library for modern C++
+//
+//	Copyright (C) 2013-2018 Ryo Suzuki <reputeless@gmail.com>
+//
+//	Permission is hereby granted, free of charge, to any person obtaining a copy
+//	of this software and associated documentation files(the "Software"), to deal
+//	in the Software without restriction, including without limitation the rights
+//	to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+//	copies of the Software, and to permit persons to whom the Software is
+//	furnished to do so, subject to the following conditions :
+//	
+//	The above copyright notice and this permission notice shall be included in
+//	all copies or substantial portions of the Software.
+//	
+//	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+//	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//	THE SOFTWARE.
+//
+//----------------------------------------------------------------------------------------
+
+# pragma once
+# include <cstdint>
+# include <numeric>
+# include <algorithm>
+# include <random>
+
+namespace siv
+{
+	class PerlinNoise
+	{
+	private:
+
+		std::uint8_t p[512];
+
+		static double Fade(double t) noexcept
+		{
+			return t * t * t * (t * (t * 6 - 15) + 10);
+		}
+
+		static double Lerp(double t, double a, double b) noexcept
+		{
+			return a + t * (b - a);
+		}
+
+		static double Grad(std::uint8_t hash, double x, double y, double z) noexcept
+		{
+			const std::uint8_t h = hash & 15;
+			const double u = h < 8 ? x : y;
+			const double v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+			return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+		}
+
+	public:
+
+		explicit PerlinNoise(std::uint32_t seed = std::default_random_engine::default_seed)
+		{
+			reseed(seed);
+		}
+
+		template <class URNG>
+		explicit PerlinNoise(URNG& urng)
+		{
+			reseed(urng);
+		}
+
+		void reseed(std::uint32_t seed)
+		{
+			for (size_t i = 0; i < 256; ++i)
+			{
+				p[i] = static_cast<std::uint8_t>(i);
+			}
+
+			std::shuffle(std::begin(p), std::begin(p) + 256, std::default_random_engine(seed));
+
+			for (size_t i = 0; i < 256; ++i)
+			{
+				p[256 + i] = p[i];
+			}
+		}
+
+		template <class URNG>
+		void reseed(URNG& urng)
+		{
+			for (size_t i = 0; i < 256; ++i)
+			{
+				p[i] = static_cast<std::uint8_t>(i);
+			}
+
+			std::shuffle(std::begin(p), std::begin(p) + 256, urng);
+
+			for (size_t i = 0; i < 256; ++i)
+			{
+				p[256 + i] = p[i];
+			}
+		}
+
+		double noise(double x) const
+		{
+			return noise(x, 0.0, 0.0);
+		}
+
+		double noise(double x, double y) const
+		{
+			return noise(x, y, 0.0);
+		}
+
+		double noise(double x, double y, double z) const
+		{
+			const std::int32_t X = static_cast<std::int32_t>(std::floor(x)) & 255;
+			const std::int32_t Y = static_cast<std::int32_t>(std::floor(y)) & 255;
+			const std::int32_t Z = static_cast<std::int32_t>(std::floor(z)) & 255;
+
+			x -= std::floor(x);
+			y -= std::floor(y);
+			z -= std::floor(z);
+
+			const double u = Fade(x);
+			const double v = Fade(y);
+			const double w = Fade(z);
+
+			const std::int32_t A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z;
+			const std::int32_t B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z;
+
+			return Lerp(w, Lerp(v, Lerp(u, Grad(p[AA], x, y, z),
+				Grad(p[BA], x - 1, y, z)),
+				Lerp(u, Grad(p[AB], x, y - 1, z),
+				Grad(p[BB], x - 1, y - 1, z))),
+				Lerp(v, Lerp(u, Grad(p[AA + 1], x, y, z - 1),
+				Grad(p[BA + 1], x - 1, y, z - 1)),
+				Lerp(u, Grad(p[AB + 1], x, y - 1, z - 1),
+				Grad(p[BB + 1], x - 1, y - 1, z - 1))));
+		}
+
+		double octaveNoise(double x, std::int32_t octaves) const
+		{
+			double result = 0.0;
+			double amp = 1.0;
+
+			for (std::int32_t i = 0; i < octaves; ++i)
+			{
+				result += noise(x) * amp;
+				x *= 2.0;
+				amp *= 0.5;
+			}
+
+			return result;
+		}
+
+		double octaveNoise(double x, double y, std::int32_t octaves) const
+		{
+			double result = 0.0;
+			double amp = 1.0;
+
+			for (std::int32_t i = 0; i < octaves; ++i)
+			{
+				result += noise(x, y) * amp;
+				x *= 2.0;
+				y *= 2.0;
+				amp *= 0.5;
+			}
+
+			return result;
+		}
+
+		double octaveNoise(double x, double y, double z, std::int32_t octaves) const
+		{
+			double result = 0.0;
+			double amp = 1.0;
+
+			for (std::int32_t i = 0; i < octaves; ++i)
+			{
+				result += noise(x, y, z) * amp;
+				x *= 2.0;
+				y *= 2.0;
+				z *= 2.0;
+				amp *= 0.5;
+			}
+
+			return result;
+		}
+
+		double noise0_1(double x) const
+		{
+			return noise(x) * 0.5 + 0.5;
+		}
+
+		double noise0_1(double x, double y) const
+		{
+			return noise(x, y) * 0.5 + 0.5;
+		}
+
+		double noise0_1(double x, double y, double z) const
+		{
+			return noise(x, y, z) * 0.5 + 0.5;
+		}
+
+		double octaveNoise0_1(double x, std::int32_t octaves) const
+		{
+			return octaveNoise(x, octaves) * 0.5 + 0.5;
+		}
+
+		double octaveNoise0_1(double x, double y, std::int32_t octaves) const
+		{
+			return octaveNoise(x, y, octaves) * 0.5 + 0.5;
+		}
+
+		double octaveNoise0_1(double x, double y, double z, std::int32_t octaves) const
+		{
+			return octaveNoise(x, y, z, octaves) * 0.5 + 0.5;
+		}
+	};
+}