38 files changed, 1483 insertions, 593 deletions

diff --git a/MCServer/Plugins/APIDump/APIDesc.lua b/MCServer/Plugins/APIDump/APIDesc.lua
index 01e945e73..9b87781a6 100644
--- a/MCServer/Plugins/APIDump/APIDesc.lua
+++ b/MCServer/Plugins/APIDump/APIDesc.lua
@@ -534,6 +534,7 @@ end
 				GetUUID = { Params = "", Return = "string", Notes = "Returns the authentication-based UUID of the client. This UUID should be used to identify the player when persisting any player-related data. Returns a 32-char UUID (no dashes)" },
 				GetUsername = { Params = "", Return = "string", Notes = "Returns the username that the client has provided" },
 				GetViewDistance = { Params = "", Return = "number", Notes = "Returns the viewdistance (number of chunks loaded for the player in each direction)" },
+				GetRequestedViewDistance = { Params = "", Return = "number", Notes = "Returns the view distance that the player request, not the used view distance." },
 				HasPluginChannel = { Params = "ChannelName", Return = "bool", Notes = "Returns true if the client has registered to receive messages on the specified plugin channel." },
 				IsUUIDOnline = { Params = "UUID", Return = "bool", Notes = "(STATIC) Returns true if the UUID is generated by online auth, false if it is an offline-generated UUID. We use Version-3 UUIDs for offline UUIDs, online UUIDs are Version-4, thus we can tell them apart. Accepts both 32-char and 36-char UUIDs (with and without dashes). If the string given is not a valid UUID, returns false."},
 				Kick = { Params = "Reason", Return = "", Notes = "Kicks the user with the specified reason" },
@@ -614,7 +615,7 @@ function OnPlayerJoined(a_Player)
 	-- Send an example composite chat message to the player:
 	a_Player:SendMessage(cCompositeChat()
 		:AddTextPart("Hello, ")
-		:AddUrlPart(a_Player:GetName(), "www.mc-server.org", "u@2")  -- Colored underlined link
+		:AddUrlPart(a_Player:GetName(), "http://www.mc-server.org", "u@2")  -- Colored underlined link
 		:AddSuggestCommandPart(", and welcome.", "/help", "u")       -- Underlined suggest-command
 		:AddRunCommandPart(" SetDay", "/time set 0")                 -- Regular text that will execute command when clicked
 		:SetMessageType(mtJoin)                                      -- It is a join-message
@@ -2499,7 +2500,7 @@ end
 				SetCommandBlocksEnabled = { Params = "IsEnabled (bool)", Return = "", Notes = "Sets whether command blocks should be enabled on the (entire) server." },
 				SetShouldUseChatPrefixes = { Params = "", Return = "ShouldUse (bool)", Notes = "Sets whether coloured chat prefixes such as [INFO] is used with the SendMessageXXX() or BroadcastChatXXX(), or simply the entire message is coloured in the respective colour." },
 				ShouldUseChatPrefixes = { Params = "", Return = "bool", Notes = "Returns whether coloured chat prefixes are prepended to chat messages or the entire message is simply coloured." },
-				SetSignLines = { Params = "X, Y, Z, Line1, Line2, Line3, Line4, [{{cPlayer|Player}}]", Return = "", Notes = "Sets the sign text at the specified coords. The sign-updating hooks are called for the change. The Player parameter is used to indicate the player from whom the change has come, it may be nil. Same as UpdateSign()." },
+				SetSignLines = { Params = "X, Y, Z, Line1, Line2, Line3, Line4, [{{cPlayer|Player}}]", Return = "", Notes = "Sets the sign text at the specified coords. The sign-updating hooks are called for the change. The Player parameter is used to indicate the player from whom the change has come, it may be nil." },
 				SetTicksUntilWeatherChange = { Params = "NumTicks", Return = "", Notes = "Sets the number of ticks after which the weather will be changed." },
 				SetTimeOfDay = { Params = "TimeOfDayTicks", Return = "", Notes = "Sets the time of day, expressed as number of ticks past sunrise, in the range 0 .. 24000." },
 				SetWeather = { Params = "Weather", Return = "", Notes = "Sets the current weather (wSunny, wRain, wStorm) and resets the TicksUntilWeatherChange to the default value for the new weather. The normal weather-changing hooks are called for the change." },
@@ -2514,7 +2515,7 @@ end
 				SpawnExperienceOrb = { Params = "X, Y, Z, Reward", Return = "EntityID", Notes = "Spawns an {{cExpOrb|experience orb}} at the specified coords, with the given reward" },
 				SpawnPrimedTNT = { Params = "X, Y, Z, FuseTicks, InitialVelocityCoeff", Return = "", Notes = "Spawns a {{cTNTEntity|primed TNT entity}} at the specified coords, with the given fuse ticks. The entity gets a random speed multiplied by the InitialVelocityCoeff, 1 being the default value." },
 				TryGetHeight = { Params = "BlockX, BlockZ", Return = "IsValid, Height", Notes = "Returns true and height of the highest non-air block if the chunk is loaded, or false otherwise." },
-				UpdateSign = { Params = "X, Y, Z, Line1, Line2, Line3, Line4, [{{cPlayer|Player}}]", Return = "", Notes = "Sets the sign text at the specified coords. The sign-updating hooks are called for the change. The Player parameter is used to indicate the player from whom the change has come, it may be nil. Same as SetSignLiens()" },
+				UpdateSign = { Params = "X, Y, Z, Line1, Line2, Line3, Line4, [{{cPlayer|Player}}]", Return = "", Notes = "(<b>DEPRECATED</b>) Please use SetSignLines()." },
 				UseBlockEntity = { Params = "{{cPlayer|Player}}, BlockX, BlockY, BlockZ", Return = "", Notes = "Makes the specified Player use the block entity at the specified coords (open chest UI, etc.) If the cords are in an unloaded chunk or there's no block entity, ignores the call." },
 				WakeUpSimulators = { Params = "BlockX, BlockY, BlockZ", Return = "", Notes = "Wakes up the simulators for the specified block." },
 				WakeUpSimulatorsInArea = { Params = "MinBlockX, MaxBlockX, MinBlockY, MaxBlockY, MinBlockZ, MaxBlockZ", Return = "", Notes = "Wakes up the simulators for all the blocks in the specified area (edges inclusive)." },
diff --git a/src/Bindings/DeprecatedBindings.cpp b/src/Bindings/DeprecatedBindings.cpp
index ded7a0142..345ab2a07 100644
--- a/src/Bindings/DeprecatedBindings.cpp
+++ b/src/Bindings/DeprecatedBindings.cpp
@@ -7,6 +7,9 @@
 
 
 #include "../BlockInfo.h"
+#include "../World.h"
+#include "../Entities/Player.h"
+#include "LuaState.h"
 
 
 
@@ -222,6 +225,64 @@ static int tolua_get_AllToLua_g_BlockFullyOccupiesVoxel(lua_State* tolua_S)
 
 
 
+/** function: cWorld:SetSignLines */
+static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
+{
+	cLuaState LuaState(tolua_S);
+
+	#ifndef TOLUA_RELEASE
+	tolua_Error tolua_err;
+	if (
+		!tolua_isusertype (LuaState, 1, "cWorld", 0, &tolua_err) ||
+		!tolua_isnumber   (LuaState, 2, 0, &tolua_err) ||
+		!tolua_isnumber   (LuaState, 3, 0, &tolua_err) ||
+		!tolua_isnumber   (LuaState, 4, 0, &tolua_err) ||
+		!tolua_iscppstring(LuaState, 5, 0, &tolua_err) ||
+		!tolua_iscppstring(LuaState, 6, 0, &tolua_err) ||
+		!tolua_iscppstring(LuaState, 7, 0, &tolua_err) ||
+		!tolua_iscppstring(LuaState, 8, 0, &tolua_err) ||
+		!tolua_isusertype (LuaState, 9, "cPlayer", 1, &tolua_err) ||
+		!tolua_isnoobj    (LuaState, 10, &tolua_err)
+		)
+		goto tolua_lerror;
+	else
+	#endif
+	{
+		cWorld * self       = (cWorld *) tolua_tousertype (LuaState, 1, nullptr);
+		int BlockX          = (int)      tolua_tonumber   (LuaState, 2, 0);
+		int BlockY          = (int)      tolua_tonumber   (LuaState, 3, 0);
+		int BlockZ          = (int)      tolua_tonumber   (LuaState, 4, 0);
+		const AString Line1 =            tolua_tocppstring(LuaState, 5, 0);
+		const AString Line2 =            tolua_tocppstring(LuaState, 6, 0);
+		const AString Line3 =            tolua_tocppstring(LuaState, 7, 0);
+		const AString Line4 =            tolua_tocppstring(LuaState, 8, 0);
+		cPlayer * Player    = (cPlayer *)tolua_tousertype (LuaState, 9, nullptr);
+		#ifndef TOLUA_RELEASE
+		if (self == nullptr)
+		{
+			tolua_error(LuaState, "invalid 'self' in function 'UpdateSign'", nullptr);
+		}
+		#endif
+		{
+			bool res = self->SetSignLines(BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4, Player);
+			tolua_pushboolean(LuaState, res ? 1 : 0);
+		}
+	}
+	LOGWARNING("Warning in function call 'UpdateSign': UpdateSign() is deprecated. Please use SetSignLines()");
+	LuaState.LogStackTrace(0);
+	return 1;
+	
+	#ifndef TOLUA_RELEASE
+tolua_lerror:
+	tolua_error(LuaState, "#ferror in function 'UpdateSign'.", &tolua_err);
+	return 0;
+	#endif
+}
+
+
+
+
+
 void DeprecatedBindings::Bind(lua_State * tolua_S)
 {
 	tolua_beginmodule(tolua_S, nullptr);
@@ -235,6 +296,10 @@ void DeprecatedBindings::Bind(lua_State * tolua_S)
 	tolua_array(tolua_S, "g_BlockIsSolid",             tolua_get_AllToLua_g_BlockIsSolid,             nullptr);
 	tolua_array(tolua_S, "g_BlockFullyOccupiesVoxel",  tolua_get_AllToLua_g_BlockFullyOccupiesVoxel,  nullptr);
 
+	tolua_beginmodule(tolua_S, "cWorld");
+		tolua_function(tolua_S, "UpdateSign", tolua_cWorld_SetSignLines);
+	tolua_endmodule(tolua_S);
+
 	tolua_endmodule(tolua_S);
 }
 
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index 3d10e2abb..750f7c65a 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -1034,11 +1034,11 @@ static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
 		#ifndef TOLUA_RELEASE
 		if (self == nullptr)
 		{
-			tolua_error(tolua_S, "invalid 'self' in function 'SetSignLines' / 'UpdateSign'", nullptr);
+			tolua_error(tolua_S, "invalid 'self' in function 'SetSignLines'", nullptr);
 		}
 		#endif
 		{
-			bool res = self->UpdateSign(BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4, Player);
+			bool res = self->SetSignLines(BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4, Player);
 			tolua_pushboolean(tolua_S, res ? 1 : 0);
 		}
 	}
@@ -1046,7 +1046,7 @@ static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
 	
 	#ifndef TOLUA_RELEASE
 tolua_lerror:
-	tolua_error(tolua_S, "#ferror in function 'SetSignLines' / 'UpdateSign'.", &tolua_err);
+	tolua_error(tolua_S, "#ferror in function 'SetSignLines'.", &tolua_err);
 	return 0;
 	#endif
 }
@@ -3405,7 +3405,6 @@ void ManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "ScheduleTask",              tolua_cWorld_ScheduleTask);
 			tolua_function(tolua_S, "SetSignLines",              tolua_cWorld_SetSignLines);
 			tolua_function(tolua_S, "TryGetHeight",              tolua_cWorld_TryGetHeight);
-			tolua_function(tolua_S, "UpdateSign",                tolua_cWorld_SetSignLines);
 		tolua_endmodule(tolua_S);
 		
 		tolua_beginmodule(tolua_S, "cMapManager");
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 096fa824d..9720c9941 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -9,6 +9,7 @@ include_directories (SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/../lib/polarssl/include
 set(FOLDERS
 	OSSupport HTTPServer Items Blocks Protocol Generating PolarSSL++ Bindings
 	WorldStorage Mobs Entities Simulator UI BlockEntities Generating/Prefabs
+	Noise
 )
 
 SET (SRCS
@@ -50,7 +51,6 @@ SET (SRCS
 	MobProximityCounter.cpp
 	MobSpawner.cpp
 	MonsterConfig.cpp
-	Noise.cpp
 	ProbabDistrib.cpp
 	RankManager.cpp
 	RCONServer.cpp
@@ -65,7 +65,8 @@ SET (SRCS
 	VoronoiMap.cpp
 	WebAdmin.cpp
 	World.cpp
-	main.cpp)
+	main.cpp
+)
 
 SET (HDRS
 	AllocationPool.h
@@ -120,7 +121,6 @@ SET (HDRS
 	MobProximityCounter.h
 	MobSpawner.h
 	MonsterConfig.h
-	Noise.h
 	ProbabDistrib.h
 	RankManager.h
 	RCONServer.h
@@ -137,7 +137,8 @@ SET (HDRS
 	VoronoiMap.h
 	WebAdmin.h
 	World.h
-	XMLParser.h)
+	XMLParser.h
+)
 
 include_directories(".")
 include_directories ("${CMAKE_CURRENT_SOURCE_DIR}/../lib/sqlite")
@@ -314,7 +315,7 @@ endif ()
 
 if (NOT MSVC)
 	target_link_libraries(${EXECUTABLE}
-		OSSupport HTTPServer Bindings Items Blocks
+		OSSupport HTTPServer Bindings Items Blocks Noise
 		Protocol Generating Generating_Prefabs WorldStorage
 		Mobs Entities Simulator UI BlockEntities PolarSSL++
 	)
diff --git a/src/Chunk.cpp b/src/Chunk.cpp
index a0224322a..d9333afc7 100644
--- a/src/Chunk.cpp
+++ b/src/Chunk.cpp
@@ -25,7 +25,7 @@
 #include "BlockEntities/FlowerPotEntity.h"
 #include "Entities/Pickup.h"
 #include "Item.h"
-#include "Noise.h"
+#include "Noise/Noise.h"
 #include "Root.h"
 #include "MersenneTwister.h"
 #include "Entities/Player.h"
diff --git a/src/ClientHandle.cpp b/src/ClientHandle.cpp
index 94bace43a..c4ce721c3 100644
--- a/src/ClientHandle.cpp
+++ b/src/ClientHandle.cpp
@@ -65,7 +65,8 @@ int cClientHandle::s_ClientCount = 0;
 // cClientHandle:
 
 cClientHandle::cClientHandle(const cSocket * a_Socket, int a_ViewDistance) :
-	m_ViewDistance(a_ViewDistance),
+	m_CurrentViewDistance(a_ViewDistance),
+	m_RequestedViewDistance(a_ViewDistance),
 	m_IPString(a_Socket->GetIPString()),
 	m_OutgoingData(64 KiB),
 	m_Player(nullptr),
@@ -93,6 +94,7 @@ cClientHandle::cClientHandle(const cSocket * a_Socket, int a_ViewDistance) :
 	m_UniqueID(0),
 	m_HasSentPlayerChunk(false),
 	m_Locale("en_GB"),
+	m_LastPlacedSign(0, -1, 0),
 	m_ProtocolVersion(0)
 {
 	m_Protocol = new cProtocolRecognizer(this);
@@ -430,7 +432,7 @@ bool cClientHandle::StreamNextChunk(void)
 	cCSLock Lock(m_CSChunkLists);
 
 	// High priority: Load the chunks that are in the view-direction of the player (with a radius of 3)
-	for (int Range = 0; Range < m_ViewDistance; Range++)
+	for (int Range = 0; Range < m_CurrentViewDistance; Range++)
 	{
 		Vector3d Vector = Position + LookVector * cChunkDef::Width * Range;
 
@@ -447,7 +449,7 @@ bool cClientHandle::StreamNextChunk(void)
 				cChunkCoords Coords(ChunkX, ChunkZ);
 
 				// Checks if the chunk is in distance
-				if ((Diff(ChunkX, ChunkPosX) > m_ViewDistance) || (Diff(ChunkZ, ChunkPosZ) > m_ViewDistance))
+				if ((Diff(ChunkX, ChunkPosX) > m_CurrentViewDistance) || (Diff(ChunkZ, ChunkPosZ) > m_CurrentViewDistance))
 				{
 					continue;
 				}
@@ -470,7 +472,7 @@ bool cClientHandle::StreamNextChunk(void)
 	}
 
 	// Low priority: Add all chunks that are in range. (From the center out to the edge)
-	for (int d = 0; d <= m_ViewDistance; ++d)  // cycle through (square) distance, from nearest to furthest
+	for (int d = 0; d <= m_CurrentViewDistance; ++d)  // cycle through (square) distance, from nearest to furthest
 	{
 		// For each distance add chunks in a hollow square centered around current position:
 		cChunkCoordsList CurcleChunks;
@@ -528,7 +530,7 @@ void cClientHandle::UnloadOutOfRangeChunks(void)
 		{
 			int DiffX = Diff((*itr).m_ChunkX, ChunkPosX);
 			int DiffZ = Diff((*itr).m_ChunkZ, ChunkPosZ);
-			if ((DiffX > m_ViewDistance) || (DiffZ > m_ViewDistance))
+			if ((DiffX > m_CurrentViewDistance) || (DiffZ > m_CurrentViewDistance))
 			{
 				ChunksToRemove.push_back(*itr);
 				itr = m_LoadedChunks.erase(itr);
@@ -543,7 +545,7 @@ void cClientHandle::UnloadOutOfRangeChunks(void)
 		{
 			int DiffX = Diff((*itr).m_ChunkX, ChunkPosX);
 			int DiffZ = Diff((*itr).m_ChunkZ, ChunkPosZ);
-			if ((DiffX > m_ViewDistance) || (DiffZ > m_ViewDistance))
+			if ((DiffX > m_CurrentViewDistance) || (DiffZ > m_CurrentViewDistance))
 			{
 				itr = m_ChunksToSend.erase(itr);
 			}
@@ -1500,6 +1502,7 @@ void cClientHandle::HandlePlaceBlock(int a_BlockX, int a_BlockY, int a_BlockZ, e
 	{
 		m_Player->GetInventory().RemoveOneEquippedItem();
 	}
+
 	cChunkInterface ChunkInterface(World->GetChunkMap());
 	NewBlock->OnPlacedByPlayer(ChunkInterface, *World, m_Player, a_BlockX, a_BlockY, a_BlockZ, a_BlockFace, a_CursorX, a_CursorY, a_CursorZ, BlockType, BlockMeta);
 	
@@ -1677,8 +1680,11 @@ void cClientHandle::HandleUpdateSign(
 	const AString & a_Line3, const AString & a_Line4
 )
 {
-	cWorld * World = m_Player->GetWorld();
-	World->UpdateSign(a_BlockX, a_BlockY, a_BlockZ, a_Line1, a_Line2, a_Line3, a_Line4, m_Player);
+	if (m_LastPlacedSign.Equals(Vector3i(a_BlockX, a_BlockY, a_BlockZ)))
+	{
+		m_LastPlacedSign.Set(0, -1, 0);
+		m_Player->GetWorld()->SetSignLines(a_BlockX, a_BlockY, a_BlockZ, a_Line1, a_Line2, a_Line3, a_Line4, m_Player);
+	}
 }
 
 
@@ -2257,6 +2263,7 @@ void cClientHandle::SendDisconnect(const AString & a_Reason)
 
 void cClientHandle::SendEditSign(int a_BlockX, int a_BlockY, int a_BlockZ)
 {
+	m_LastPlacedSign.Set(a_BlockX, a_BlockY, a_BlockZ);
 	m_Protocol->SendEditSign(a_BlockX, a_BlockY, a_BlockZ);
 }
 
@@ -2847,8 +2854,15 @@ void cClientHandle::SetUsername( const AString & a_Username)
 
 void cClientHandle::SetViewDistance(int a_ViewDistance)
 {
-	m_ViewDistance = Clamp(a_ViewDistance, MIN_VIEW_DISTANCE, MAX_VIEW_DISTANCE);
-	LOGD("Setted %s's view distance to %i", GetUsername().c_str(), m_ViewDistance);
+	m_RequestedViewDistance = a_ViewDistance;
+	LOGD("%s is requesting ViewDistance of %d!", GetUsername().c_str(), m_RequestedViewDistance);
+
+	// Set the current view distance based on the requested VD and world max VD:
+	cWorld * world = m_Player->GetWorld();
+	if (world != nullptr)
+	{
+		m_CurrentViewDistance = Clamp(a_ViewDistance, cClientHandle::MIN_VIEW_DISTANCE, world->GetMaxViewDistance());
+	}
 }
 
 
diff --git a/src/ClientHandle.h b/src/ClientHandle.h
index 082ed2fcc..f195b6be7 100644
--- a/src/ClientHandle.h
+++ b/src/ClientHandle.h
@@ -217,9 +217,15 @@ public:
 	
 	inline short GetPing(void) const { return m_Ping; }
 	
+	/** Sets the maximal view distance. */
 	void SetViewDistance(int a_ViewDistance);
-	int  GetViewDistance(void) const { return m_ViewDistance; }
-	
+
+	/** Returns the view distance that the player currently have. */
+	int GetViewDistance(void) const { return m_CurrentViewDistance; }
+
+	/** Returns the view distance that the player request, not the used view distance. */
+	int GetRequestedViewDistance(void) const { return m_RequestedViewDistance; }
+
 	void SetLocale(AString & a_Locale) { m_Locale = a_Locale; }
 	AString GetLocale(void) const { return m_Locale; }
 
@@ -333,12 +339,12 @@ private:
 	/** The type used for storing the names of registered plugin channels. */
 	typedef std::set<AString> cChannels;
 
-	/** Number of chunks the player can see in each direction */
-	int m_ViewDistance;
-	
-	/** Server generates this many chunks AHEAD of player sight. */
-	static const int GENERATEDISTANCE = 2;
-	
+	/** The actual view distance used, the minimum of client's requested view distance and world's max view distance. */
+	int m_CurrentViewDistance;
+
+	/** The requested view distance from the player. It isn't clamped with 1 and the max view distance of the world. */
+	int m_RequestedViewDistance;
+
 	AString m_IPString;
 
 	AString m_Username;
@@ -432,6 +438,9 @@ private:
 
 	/** Client Settings */
 	AString m_Locale;
+
+	/** The positions from the last sign that the player placed. It's needed to verify the sign text change. */
+	Vector3i m_LastPlacedSign;
 	
 	/** The plugin channels that the client has registered. */
 	cChannels m_PluginChannels;
diff --git a/src/Enchantments.cpp b/src/Enchantments.cpp
index 80a9810b6..36c451b81 100644
--- a/src/Enchantments.cpp
+++ b/src/Enchantments.cpp
@@ -6,7 +6,7 @@
 #include "Enchantments.h"
 #include "WorldStorage/FastNBT.h"
 #include "FastRandom.h"
-#include "Noise.h"
+#include "Noise/Noise.h"
 
 
 
diff --git a/src/Entities/Player.cpp b/src/Entities/Player.cpp
index 5c18d8f96..edcdb4799 100644
--- a/src/Entities/Player.cpp
+++ b/src/Entities/Player.cpp
@@ -1602,6 +1602,9 @@ bool cPlayer::DoMoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn)
 	a_World->AddPlayer(this);
 	SetWorld(a_World);  // Chunks may be streamed before cWorld::AddPlayer() sets the world to the new value
 
+	// Update the view distance.
+	m_ClientHandle->SetViewDistance(m_ClientHandle->GetRequestedViewDistance());
+
 	return true;
 }
 
diff --git a/src/Generating/BioGen.h b/src/Generating/BioGen.h
index 5fd0844d9..13fb40c5f 100644
--- a/src/Generating/BioGen.h
+++ b/src/Generating/BioGen.h
@@ -15,7 +15,7 @@ Interfaces to the various biome generators:
 #pragma once
 
 #include "ComposableGenerator.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 #include "../VoronoiMap.h"
 
 
diff --git a/src/Generating/Caves.h b/src/Generating/Caves.h
index 0e17acf9e..691ef3e62 100644
--- a/src/Generating/Caves.h
+++ b/src/Generating/Caves.h
@@ -13,7 +13,6 @@
 #pragma once
 
 #include "GridStructGen.h"
-#include "../Noise.h"
 
 
 
diff --git a/src/Generating/ChunkDesc.cpp b/src/Generating/ChunkDesc.cpp
index 3fe81c7e4..4a5ac5a18 100644
--- a/src/Generating/ChunkDesc.cpp
+++ b/src/Generating/ChunkDesc.cpp
@@ -7,7 +7,7 @@
 #include "ChunkDesc.h"
 #include "../BlockArea.h"
 #include "../Cuboid.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 #include "../BlockEntities/BlockEntity.h"
 
 
diff --git a/src/Generating/CompoGen.h b/src/Generating/CompoGen.h
index 03df0cf25..3847688cd 100644
--- a/src/Generating/CompoGen.h
+++ b/src/Generating/CompoGen.h
@@ -17,7 +17,7 @@
 #pragma once
 
 #include "ComposableGenerator.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 
 
 
diff --git a/src/Generating/DistortedHeightmap.h b/src/Generating/DistortedHeightmap.h
index 4027a94ca..79fc35542 100644
--- a/src/Generating/DistortedHeightmap.h
+++ b/src/Generating/DistortedHeightmap.h
@@ -11,7 +11,6 @@
 
 #include "ComposableGenerator.h"
 #include "HeiGen.h"
-#include "../Noise.h"
 
 
 
diff --git a/src/Generating/EndGen.h b/src/Generating/EndGen.h
index e4c874014..f9e3f6e53 100644
--- a/src/Generating/EndGen.h
+++ b/src/Generating/EndGen.h
@@ -10,7 +10,7 @@
 #pragma once
 
 #include "ComposableGenerator.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 
 
 
diff --git a/src/Generating/FinishGen.cpp b/src/Generating/FinishGen.cpp
index f67d59998..2ff3e7f67 100644
--- a/src/Generating/FinishGen.cpp
+++ b/src/Generating/FinishGen.cpp
@@ -10,7 +10,6 @@
 #include "Globals.h"
 
 #include "FinishGen.h"
-#include "../Noise.h"
 #include "../BlockID.h"
 #include "../Simulator/FluidSimulator.h"  // for cFluidSimulator::CanWashAway()
 #include "../Simulator/FireSimulator.h"
diff --git a/src/Generating/FinishGen.h b/src/Generating/FinishGen.h
index 4a08d70c8..991a85787 100644
--- a/src/Generating/FinishGen.h
+++ b/src/Generating/FinishGen.h
@@ -16,7 +16,7 @@
 
 
 #include "ComposableGenerator.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 #include "../ProbabDistrib.h"
 
 
diff --git a/src/Generating/GridStructGen.h b/src/Generating/GridStructGen.h
index 03131fce9..b92fb2e9d 100644
--- a/src/Generating/GridStructGen.h
+++ b/src/Generating/GridStructGen.h
@@ -10,7 +10,7 @@
 #pragma once
 
 #include "ComposableGenerator.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 
 
 
diff --git a/src/Generating/HeiGen.h b/src/Generating/HeiGen.h
index fe0a023e4..9c99a9326 100644
--- a/src/Generating/HeiGen.h
+++ b/src/Generating/HeiGen.h
@@ -17,7 +17,7 @@ Also implements the heightmap cache
 #pragma once
 
 #include "ComposableGenerator.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 
 
 
diff --git a/src/Generating/MineShafts.h b/src/Generating/MineShafts.h
index 2850db571..efb11cfee 100644
--- a/src/Generating/MineShafts.h
+++ b/src/Generating/MineShafts.h
@@ -10,7 +10,6 @@
 #pragma once
 
 #include "GridStructGen.h"
-#include "../Noise.h"
 
 
 
diff --git a/src/Generating/Noise3DGenerator.cpp b/src/Generating/Noise3DGenerator.cpp
index da4632de4..70844e6fa 100644
--- a/src/Generating/Noise3DGenerator.cpp
+++ b/src/Generating/Noise3DGenerator.cpp
@@ -6,6 +6,7 @@
 #include "Globals.h"
 #include "Noise3DGenerator.h"
 #include "../OSSupport/File.h"
+#include "../OSSupport/Timer.h"
 #include "../IniFile.h"
 #include "../LinearInterpolation.h"
 #include "../LinearUpscale.h"
@@ -61,30 +62,86 @@ public:
 
 
 
-/** Linearly interpolates between two values.
-Assumes that a_Ratio is in range [0, 1]. */
-inline static NOISE_DATATYPE Lerp(NOISE_DATATYPE a_Val1, NOISE_DATATYPE a_Val2, NOISE_DATATYPE a_Ratio)
+#if 0
+// Perform speed test of the cInterpolNoise class
+static class cInterpolNoiseSpeedTest
 {
-	return a_Val1 + (a_Val2 - a_Val1) * a_Ratio;
-}
+public:
+	cInterpolNoiseSpeedTest(void)
+	{
+		TestSpeed2D();
+		TestSpeed3D();
+		printf("InterpolNoise speed comparison finished.\n");
+	}
 
 
+	/** Compare the speed of the 3D InterpolNoise vs 3D CubicNoise. */
+	void TestSpeed3D(void)
+	{
+		printf("Evaluating 3D noise performance...\n");
+		static const int SIZE_X = 128;
+		static const int SIZE_Y = 128;
+		static const int SIZE_Z = 128;
+		static const NOISE_DATATYPE MUL = 80;
+		std::unique_ptr<NOISE_DATATYPE[]> arr(new NOISE_DATATYPE[SIZE_X * SIZE_Y * SIZE_Z]);
+		cTimer timer;
+
+		// Test the cInterpolNoise:
+		cInterpolNoise<Interp5Deg> interpNoise(1);
+		long long start = timer.GetNowTime();
+		for (int i = 0; i < 30; i++)
+		{
+			interpNoise.Generate3D(arr.get(), SIZE_X, SIZE_Y, SIZE_Z, MUL * i, MUL * i + MUL, 0, MUL, 0, MUL);
+		}
+		long long end = timer.GetNowTime();
+		printf("InterpolNoise took %.02f sec\n", static_cast<float>(end - start) / 1000);
 
+		// Test the cCubicNoise:
+		cCubicNoise cubicNoise(1);
+		start = timer.GetNowTime();
+		for (int i = 0; i < 30; i++)
+		{
+			cubicNoise.Generate3D(arr.get(), SIZE_X, SIZE_Y, SIZE_Z, MUL * i, MUL * i + MUL, 0, MUL, 0, MUL);
+		}
+		end = timer.GetNowTime();
+		printf("CubicNoise took %.02f sec\n", static_cast<float>(end - start) / 1000);
+		printf("3D noise performance comparison finished.\n");
+	}
 
 
-/** Linearly interpolates between two values, clamping the ratio to [0, 1] first. */
-inline static NOISE_DATATYPE ClampedLerp(NOISE_DATATYPE a_Val1, NOISE_DATATYPE a_Val2, NOISE_DATATYPE a_Ratio)
-{
-	if (a_Ratio < 0)
-	{
-		return a_Val1;
-	}
-	if (a_Ratio > 1)
+	/** Compare the speed of the 2D InterpolNoise vs 2D CubicNoise. */
+	void TestSpeed2D(void)
 	{
-		return a_Val2;
+		printf("Evaluating 2D noise performance...\n");
+		static const int SIZE_X = 128;
+		static const int SIZE_Y = 128;
+		static const NOISE_DATATYPE MUL = 80;
+		std::unique_ptr<NOISE_DATATYPE[]> arr(new NOISE_DATATYPE[SIZE_X * SIZE_Y]);
+		cTimer timer;
+
+		// Test the cInterpolNoise:
+		cInterpolNoise<Interp5Deg> interpNoise(1);
+		long long start = timer.GetNowTime();
+		for (int i = 0; i < 500; i++)
+		{
+			interpNoise.Generate2D(arr.get(), SIZE_X, SIZE_Y, MUL * i, MUL * i + MUL, 0, MUL);
+		}
+		long long end = timer.GetNowTime();
+		printf("InterpolNoise took %.02f sec\n", static_cast<float>(end - start) / 1000);
+
+		// Test the cCubicNoise:
+		cCubicNoise cubicNoise(1);
+		start = timer.GetNowTime();
+		for (int i = 0; i < 500; i++)
+		{
+			cubicNoise.Generate2D(arr.get(), SIZE_X, SIZE_Y, MUL * i, MUL * i + MUL, 0, MUL);
+		}
+		end = timer.GetNowTime();
+		printf("CubicNoise took %.02f sec\n", static_cast<float>(end - start) / 1000);
+		printf("2D noise performance comparison finished.\n");
 	}
-	return Lerp(a_Val1, a_Val2, a_Ratio);
-}
+} g_InterpolNoiseSpeedTest;
+#endif
 
 
 
@@ -98,9 +155,17 @@ cNoise3DGenerator::cNoise3DGenerator(cChunkGenerator & a_ChunkGenerator) :
 	m_Perlin(1000),
 	m_Cubic(1000)
 {
-	m_Perlin.AddOctave(1, (NOISE_DATATYPE)0.5);
-	m_Perlin.AddOctave((NOISE_DATATYPE)0.5, 1);
-	m_Perlin.AddOctave((NOISE_DATATYPE)0.5, 2);
+	m_Perlin.AddOctave(1,  1);
+	m_Perlin.AddOctave(2,  0.5);
+	m_Perlin.AddOctave(4,  0.25);
+	m_Perlin.AddOctave(8,  0.125);
+	m_Perlin.AddOctave(16, 0.0625);
+
+	m_Cubic.AddOctave(1,  1);
+	m_Cubic.AddOctave(2,  0.5);
+	m_Cubic.AddOctave(4,  0.25);
+	m_Cubic.AddOctave(8,  0.125);
+	m_Cubic.AddOctave(16, 0.0625);
 
 	#if 0
 	// DEBUG: Test the noise generation:
@@ -183,8 +248,8 @@ void cNoise3DGenerator::Initialize(cIniFile & a_IniFile)
 {
 	// Params:
 	m_SeaLevel            =                 a_IniFile.GetValueSetI("Generator", "Noise3DSeaLevel", 62);
-	m_HeightAmplification = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DHeightAmplification", 0);
-	m_MidPoint            = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DMidPoint", 75);
+	m_HeightAmplification = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DHeightAmplification", 0.1);
+	m_MidPoint            = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DMidPoint", 68);
 	m_FrequencyX          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyX", 8);
 	m_FrequencyY          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyY", 8);
 	m_FrequencyZ          = (NOISE_DATATYPE)a_IniFile.GetValueSetF("Generator", "Noise3DFrequencyZ", 8);
@@ -249,10 +314,10 @@ void cNoise3DGenerator::GenerateNoiseArray(int a_ChunkX, int a_ChunkZ, NOISE_DAT
 	NOISE_DATATYPE NoiseW[DIM_X * DIM_Y * DIM_Z];  // Workspace that the noise calculation can use and trash
 
 	// Our noise array has different layout, XZY, instead of regular chunk's XYZ, that's why the coords are "renamed"
-	NOISE_DATATYPE StartX = ((NOISE_DATATYPE)(a_ChunkX       * cChunkDef::Width))     / m_FrequencyX;
-	NOISE_DATATYPE EndX   = ((NOISE_DATATYPE)((a_ChunkX + 1) * cChunkDef::Width) - 1) / m_FrequencyX;
-	NOISE_DATATYPE StartZ = ((NOISE_DATATYPE)(a_ChunkZ       * cChunkDef::Width))     / m_FrequencyZ;
-	NOISE_DATATYPE EndZ   = ((NOISE_DATATYPE)((a_ChunkZ + 1) * cChunkDef::Width) - 1) / m_FrequencyZ;
+	NOISE_DATATYPE StartX = ((NOISE_DATATYPE)(a_ChunkX       * cChunkDef::Width)) / m_FrequencyX;
+	NOISE_DATATYPE EndX   = ((NOISE_DATATYPE)((a_ChunkX + 1) * cChunkDef::Width)) / m_FrequencyX;
+	NOISE_DATATYPE StartZ = ((NOISE_DATATYPE)(a_ChunkZ       * cChunkDef::Width)) / m_FrequencyZ;
+	NOISE_DATATYPE EndZ   = ((NOISE_DATATYPE)((a_ChunkZ + 1) * cChunkDef::Width)) / m_FrequencyZ;
 	NOISE_DATATYPE StartY = 0;
 	NOISE_DATATYPE EndY   = ((NOISE_DATATYPE)256) / m_FrequencyY;
 
@@ -262,23 +327,23 @@ void cNoise3DGenerator::GenerateNoiseArray(int a_ChunkX, int a_ChunkZ, NOISE_DAT
 
 	// Precalculate a "height" array:
 	NOISE_DATATYPE Height[DIM_X * DIM_Z];  // Output for the cubic noise heightmap ("source")
-	m_Cubic.Generate2D(Height, DIM_X, DIM_Z, StartX / 25, EndX / 25, StartZ / 25, EndZ / 25);
+	m_Cubic.Generate2D(Height, DIM_X, DIM_Z, StartX / 5, EndX / 5, StartZ / 5, EndZ / 5);
 	for (size_t i = 0; i < ARRAYCOUNT(Height); i++)
 	{
-		Height[i] = std::abs(Height[i]) * m_HeightAmplification + 1;
+		Height[i] = Height[i] * m_HeightAmplification;
 	}
 
 	// Modify the noise by height data:
 	for (int y = 0; y < DIM_Y; y++)
 	{
-		NOISE_DATATYPE AddHeight = (y * UPSCALE_Y - m_MidPoint) / 20;
-		AddHeight *= AddHeight * AddHeight;
+		NOISE_DATATYPE AddHeight = (y * UPSCALE_Y - m_MidPoint) / 30;
+		// AddHeight *= AddHeight * AddHeight;
 		for (int z = 0; z < DIM_Z; z++)
 		{
 			NOISE_DATATYPE * CurRow = &(NoiseO[y * DIM_X + z * DIM_X * DIM_Y]);
 			for (int x = 0; x < DIM_X; x++)
 			{
-				CurRow[x] += AddHeight / Height[x + DIM_X * z];
+				CurRow[x] += AddHeight + Height[x + DIM_X * z];
 			}
 		}
 	}
@@ -701,14 +766,71 @@ void cBiomalNoise3DComposable::GetBiomeParams(EMCSBiome a_Biome, NOISE_DATATYPE
 {
 	switch (a_Biome)
 	{
-		case biDesert:           a_HeightAmp = 0.29f;  a_MidPoint = 62; break;  // Needs verification
-		case biExtremeHills:     a_HeightAmp = 0.045f; a_MidPoint = 75; break;
-		case biExtremeHillsPlus: a_HeightAmp = 0.04f;  a_MidPoint = 80; break;
-		case biFrozenRiver:      a_HeightAmp = 0.4f;   a_MidPoint = 53; break;
-		case biPlains:           a_HeightAmp = 0.3f;   a_MidPoint = 62; break;  // Needs verification
-		case biRiver:            a_HeightAmp = 0.4f;   a_MidPoint = 53; break;
-		case biSwampland:        a_HeightAmp = 0.25f;  a_MidPoint = 59; break;
-		case biSwamplandM:       a_HeightAmp = 0.11f;  a_MidPoint = 59; break;
+		case biBeach:                a_HeightAmp = 0.3f;   a_MidPoint = 62; break;
+		case biBirchForest:          a_HeightAmp = 0.1f;   a_MidPoint = 64; break;
+		case biBirchForestHills:     a_HeightAmp = 0.075f; a_MidPoint = 68; break;
+		case biBirchForestHillsM:    a_HeightAmp = 0.075f; a_MidPoint = 68; break;
+		case biBirchForestM:         a_HeightAmp = 0.1f;   a_MidPoint = 64; break;
+		case biColdBeach:            a_HeightAmp = 0.3f;   a_MidPoint = 62; break;
+		case biDesertHills:          a_HeightAmp = 0.075f; a_MidPoint = 68; break;
+		case biDeepOcean:            a_HeightAmp = 0.17f;  a_MidPoint = 35; break;
+		case biDesert:               a_HeightAmp = 0.29f;  a_MidPoint = 62; break;
+		case biEnd:                  a_HeightAmp = 0.15f;  a_MidPoint = 64; break;
+		case biExtremeHills:         a_HeightAmp = 0.045f; a_MidPoint = 75; break;
+		case biExtremeHillsPlus:     a_HeightAmp = 0.04f;  a_MidPoint = 80; break;
+		case biFlowerForest:         a_HeightAmp = 0.1f;   a_MidPoint = 64; break;
+		case biForest:               a_HeightAmp = 0.1f;   a_MidPoint = 64; break;
+		case biForestHills:          a_HeightAmp = 0.075f; a_MidPoint = 68; break;
+		case biFrozenRiver:          a_HeightAmp = 0.4f;   a_MidPoint = 53; break;
+		case biFrozenOcean:          a_HeightAmp = 0.17f;  a_MidPoint = 47; break;
+		case biIceMountains:         a_HeightAmp = 0.075f; a_MidPoint = 68; break;
+		case biIcePlains:            a_HeightAmp = 0.3f;   a_MidPoint = 62; break;
+		case biIcePlainsSpikes:      a_HeightAmp = 0.3f;   a_MidPoint = 62; break;
+		case biJungle:               a_HeightAmp = 0.1f;   a_MidPoint = 63; break;
+		case biJungleHills:          a_HeightAmp = 0.075f; a_MidPoint = 68; break;
+		case biJungleM:              a_HeightAmp = 0.1f;   a_MidPoint = 63; break;
+		case biMegaSpruceTaigaHills: a_HeightAmp = 0.075f; a_MidPoint = 68; break;
+		case biMegaTaigaHills:       a_HeightAmp = 0.075f; a_MidPoint = 68; break;
+		case biMushroomShore:        a_HeightAmp = 0.15f;  a_MidPoint = 15; break;
+		case biOcean:                a_HeightAmp = 0.3f;   a_MidPoint = 62; break;
+		case biPlains:               a_HeightAmp = 0.3f;   a_MidPoint = 62; break;
+		case biRiver:                a_HeightAmp = 0.4f;   a_MidPoint = 53; break;
+		case biSwampland:            a_HeightAmp = 0.25f;  a_MidPoint = 59; break;
+		case biSwamplandM:           a_HeightAmp = 0.11f;  a_MidPoint = 59; break;
+		case biTaigaHills:           a_HeightAmp = 0.075f; a_MidPoint = 68; break;
+
+		/*
+		// Still missing:
+		case biColdTaiga:            a_HeightAmp = 0.15f;  a_MidPoint = 30; break;
+		case biColdTaigaHills:       a_HeightAmp = 0.15f;  a_MidPoint = 31; break;
+		case biColdTaigaM:           a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biDesertM:              a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biExtremeHillsEdge:     a_HeightAmp = 0.15f;  a_MidPoint = 20; break;
+		case biExtremeHillsM:        a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biExtremeHillsPlusM:    a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biJungleEdge:           a_HeightAmp = 0.15f;  a_MidPoint = 23; break;
+		case biJungleEdgeM:          a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biMegaSpruceTaiga:      a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biMegaTaiga:            a_HeightAmp = 0.15f;  a_MidPoint = 32; break;
+		case biMesa:                 a_HeightAmp = 0.15f;  a_MidPoint = 37; break;
+		case biMesaBryce:            a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biMesaPlateau:          a_HeightAmp = 0.15f;  a_MidPoint = 39; break;
+		case biMesaPlateauF:         a_HeightAmp = 0.15f;  a_MidPoint = 38; break;
+		case biMesaPlateauFM:        a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biMesaPlateauM:         a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biMushroomIsland:       a_HeightAmp = 0.15f;  a_MidPoint = 14; break;
+		case biNether:               a_HeightAmp = 0.15f;  a_MidPoint = 68; break;
+		case biRoofedForest:         a_HeightAmp = 0.15f;  a_MidPoint = 29; break;
+		case biRoofedForestM:        a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biSavanna:              a_HeightAmp = 0.15f;  a_MidPoint = 35; break;
+		case biSavannaM:             a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biSavannaPlateau:       a_HeightAmp = 0.15f;  a_MidPoint = 36; break;
+		case biSavannaPlateauM:      a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biStoneBeach:           a_HeightAmp = 0.15f;  a_MidPoint = 25; break;
+		case biSunflowerPlains:      a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		case biTaiga:                a_HeightAmp = 0.15f;  a_MidPoint = 65; break;
+		case biTaigaM:               a_HeightAmp = 0.15f;  a_MidPoint = 70; break;
+		*/
 
 		default:
 		{
diff --git a/src/Generating/Noise3DGenerator.h b/src/Generating/Noise3DGenerator.h
index eaac182ba..7822a9efa 100644
--- a/src/Generating/Noise3DGenerator.h
+++ b/src/Generating/Noise3DGenerator.h
@@ -13,7 +13,8 @@
 #pragma once
 
 #include "ComposableGenerator.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
+#include "../Noise/InterpolNoise.h"
 
 
 
@@ -34,17 +35,20 @@ public:
 	
 protected:
 	// Linear interpolation step sizes, must be divisors of cChunkDef::Width and cChunkDef::Height, respectively:
-	static const int UPSCALE_X = 8;
-	static const int UPSCALE_Y = 4;
-	static const int UPSCALE_Z = 8;
+	static const int UPSCALE_X = 4;
+	static const int UPSCALE_Y = 8;
+	static const int UPSCALE_Z = 4;
 	
 	// Linear interpolation buffer dimensions, calculated from the step sizes:
 	static const int DIM_X = 1 + cChunkDef::Width  / UPSCALE_X;
 	static const int DIM_Y = 1 + cChunkDef::Height / UPSCALE_Y;
 	static const int DIM_Z = 1 + cChunkDef::Width  / UPSCALE_Z;
 
-	cPerlinNoise m_Perlin;   // The base 3D noise source for the actual composition
-	cCubicNoise  m_Cubic;    // The noise used for heightmap directing
+	/** The base 3D noise source for the actual composition */
+	cOctavedNoise<cInterp5DegNoise> m_Perlin;
+
+	/** The noise used for heightmap directing. */
+	cOctavedNoise<cInterp5DegNoise> m_Cubic;
 	
 	int            m_SeaLevel;
 	NOISE_DATATYPE m_HeightAmplification;
diff --git a/src/Generating/PieceGenerator.h b/src/Generating/PieceGenerator.h
index f06029280..43ffed7a2 100644
--- a/src/Generating/PieceGenerator.h
+++ b/src/Generating/PieceGenerator.h
@@ -20,7 +20,7 @@ Each uses a slightly different approach to generating:
 
 #include "../Defines.h"
 #include "../Cuboid.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 
 
 
diff --git a/src/Generating/Ravines.h b/src/Generating/Ravines.h
index 3e41c5ce6..b11037433 100644
--- a/src/Generating/Ravines.h
+++ b/src/Generating/Ravines.h
@@ -10,7 +10,6 @@
 #pragma once
 
 #include "GridStructGen.h"
-#include "../Noise.h"
 
 
 
diff --git a/src/Generating/StructGen.h b/src/Generating/StructGen.h
index 0c5efe622..796abf0f5 100644
--- a/src/Generating/StructGen.h
+++ b/src/Generating/StructGen.h
@@ -14,7 +14,7 @@
 #pragma once
 
 #include "ComposableGenerator.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 
 
 
diff --git a/src/Generating/Trees.h b/src/Generating/Trees.h
index c9eb7de80..cc0fa87d9 100644
--- a/src/Generating/Trees.h
+++ b/src/Generating/Trees.h
@@ -18,7 +18,7 @@ logs can overwrite others(leaves), but others shouldn't overwrite logs. This is
 #pragma once
 
 #include "../ChunkDef.h"
-#include "../Noise.h"
+#include "../Noise/Noise.h"
 
 
 
diff --git a/src/ItemGrid.cpp b/src/ItemGrid.cpp
index 55fb36a17..d49ea9df1 100644
--- a/src/ItemGrid.cpp
+++ b/src/ItemGrid.cpp
@@ -6,7 +6,7 @@
 #include "Globals.h"
 #include "ItemGrid.h"
 #include "Items/ItemHandler.h"
-#include "Noise.h"
+#include "Noise/Noise.h"
 
 
 
diff --git a/src/Noise/CMakeLists.txt b/src/Noise/CMakeLists.txt
new file mode 100644
index 000000000..e1837500f
--- /dev/null
+++ b/src/Noise/CMakeLists.txt
@@ -0,0 +1,21 @@
+
+cmake_minimum_required (VERSION 2.6)
+project (MCServer)
+
+include_directories ("${PROJECT_SOURCE_DIR}/../")
+
+SET (SRCS
+	Noise.cpp
+)
+
+SET (HDRS
+	Noise.h
+	OctavedNoise.h
+	RidgedNoise.h
+)
+
+if(NOT MSVC)
+	add_library(Noise ${SRCS} ${HDRS})
+
+	target_link_libraries(Noise OSSupport)
+endif()
diff --git a/src/Noise/InterpolNoise.h b/src/Noise/InterpolNoise.h
new file mode 100644
index 000000000..683b54563
--- /dev/null
+++ b/src/Noise/InterpolNoise.h
@@ -0,0 +1,524 @@
+
+// InterpolNoise.h
+
+// Implements the cInterpolNoise class template representing a noise that interpolates the values between integer coords from a single set of neighbors
+
+
+
+
+
+#pragma once
+
+#include "Noise.h"
+
+#define FAST_FLOOR(x) (((x) < 0) ? (((int)x) - 1) : ((int)x))
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cInterpolCell2D:
+
+template <typename T>
+class cInterpolCell2D
+{
+public:
+	cInterpolCell2D(
+		const cNoise & a_Noise,    ///< Noise to use for generating the random values
+		NOISE_DATATYPE * a_Array,  ///< Array to generate into [x + a_SizeX * y]
+		int a_SizeX, int a_SizeY,  ///< Count of the array, in each direction
+		const NOISE_DATATYPE * a_FracX,  ///< Pointer to the array that stores the X fractional values
+		const NOISE_DATATYPE * a_FracY   ///< Pointer to the attay that stores the Y fractional values
+	):
+		m_Noise(a_Noise),
+		m_WorkRnds(&m_Workspace1),
+		m_CurFloorX(0),
+		m_CurFloorY(0),
+		m_Array(a_Array),
+		m_SizeX(a_SizeX),
+		m_SizeY(a_SizeY),
+		m_FracX(a_FracX),
+		m_FracY(a_FracY)
+	{
+	}
+	
+
+	/** Generates part of the output noise array using the current m_WorkRnds[] values */
+	void Generate(
+		int a_FromX, int a_ToX,
+		int a_FromY, int a_ToY
+	)
+	{
+		for (int y = a_FromY; y < a_ToY; y++)
+		{
+			NOISE_DATATYPE Interp[2];
+			NOISE_DATATYPE FracY = T::coeff(m_FracY[y]);
+			Interp[0] = Lerp((*m_WorkRnds)[0][0], (*m_WorkRnds)[0][1], FracY);
+			Interp[1] = Lerp((*m_WorkRnds)[1][0], (*m_WorkRnds)[1][1], FracY);
+			int idx = y * m_SizeX + a_FromX;
+			for (int x = a_FromX; x < a_ToX; x++)
+			{
+				m_Array[idx++] = Lerp(Interp[0], Interp[1], T::coeff(m_FracX[x]));
+			}  // for x
+		}  // for y
+	}
+	
+
+	/** Initializes m_WorkRnds[] with the specified values of the noise at the specified integral coords. */
+	void InitWorkRnds(int a_FloorX, int a_FloorY)
+	{
+		m_CurFloorX = a_FloorX;
+		m_CurFloorY = a_FloorY;
+		(*m_WorkRnds)[0][0] = m_Noise.IntNoise2D(m_CurFloorX,     m_CurFloorY);
+		(*m_WorkRnds)[0][1] = m_Noise.IntNoise2D(m_CurFloorX,     m_CurFloorY + 1);
+		(*m_WorkRnds)[1][0] = m_Noise.IntNoise2D(m_CurFloorX + 1, m_CurFloorY);
+		(*m_WorkRnds)[1][1] = m_Noise.IntNoise2D(m_CurFloorX + 1, m_CurFloorY + 1);
+	}
+	
+
+	/** Updates m_WorkRnds[] for the new integral coords */
+	void Move(int a_NewFloorX, int a_NewFloorY)
+	{
+		// Swap the doublebuffer:
+		int OldFloorX = m_CurFloorX;
+		int OldFloorY = m_CurFloorY;
+		Workspace * OldWorkRnds = m_WorkRnds;
+		m_WorkRnds = (m_WorkRnds == &m_Workspace1) ? &m_Workspace2 : &m_Workspace1;
+	
+		// Reuse as much of the old workspace as possible:
+		// TODO: Try out if simply calculating all 4 elements each time is faster than this monster loop
+		int DiffX = OldFloorX - a_NewFloorX;
+		int DiffY = OldFloorY - a_NewFloorY;
+		for (int x = 0; x < 2; x++)
+		{
+			int cx = a_NewFloorX + x;
+			int OldX = x - DiffX;  // Where would this X be in the old grid?
+			for (int y = 0; y < 2; y++)
+			{
+				int cy = a_NewFloorY + y;
+				int OldY = y - DiffY;  // Where would this Y be in the old grid?
+				if ((OldX >= 0) && (OldX < 2) && (OldY >= 0) && (OldY < 2))
+				{
+					(*m_WorkRnds)[x][y] = (*OldWorkRnds)[OldX][OldY];
+				}
+				else
+				{
+					(*m_WorkRnds)[x][y] = (NOISE_DATATYPE)m_Noise.IntNoise2D(cx, cy);
+				}
+			}
+		}
+		m_CurFloorX = a_NewFloorX;
+		m_CurFloorY = a_NewFloorY;
+	}
+
+protected:
+	typedef NOISE_DATATYPE Workspace[2][2];
+	
+	/** The noise used for generating the values at integral coords. */
+	const cNoise & m_Noise;
+	
+	/** The current random values; points to either m_Workspace1 or m_Workspace2 (doublebuffering) */
+	Workspace * m_WorkRnds;
+
+	/** Buffer 1 for workspace doublebuffering, used in Move() */
+	Workspace m_Workspace1;
+
+	/** Buffer 2 for workspace doublebuffering, used in Move() */
+	Workspace m_Workspace2;
+
+	/** Coords of the currently calculated m_WorkRnds[]. */
+	int m_CurFloorX, m_CurFloorY;
+	
+	/** The output array to generate into. */
+	NOISE_DATATYPE * m_Array;
+
+	/** Dimensions of the output array. */
+	int m_SizeX, m_SizeY;
+
+	/** Arrays holding the fractional values of the coords in each direction. */
+	const NOISE_DATATYPE * m_FracX;
+	const NOISE_DATATYPE * m_FracY;
+} ;
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cInterpolCell3D:
+
+/** Holds a cache of the last calculated integral noise values and interpolates between them en masse.
+Provides a massive optimization for cInterpolNoise.
+Works by calculating multiple noise values (that have the same integral noise coords) at once. The underlying noise values
+needn't be recalculated for these values, only the interpolation is done within the unit cube. */
+template <typename T>
+class cInterpolCell3D
+{
+public:
+	cInterpolCell3D(
+		const cNoise & a_Noise,                 ///< Noise to use for generating the random values
+		NOISE_DATATYPE * a_Array,               ///< Array to generate into [x + a_SizeX * y]
+		int a_SizeX, int a_SizeY, int a_SizeZ,  ///< Count of the array, in each direction
+		const NOISE_DATATYPE * a_FracX,         ///< Pointer to the array that stores the X fractional values
+		const NOISE_DATATYPE * a_FracY,         ///< Pointer to the attay that stores the Y fractional values
+		const NOISE_DATATYPE * a_FracZ          ///< Pointer to the array that stores the Z fractional values
+	):
+		m_Noise(a_Noise),
+		m_WorkRnds(&m_Workspace1),
+		m_CurFloorX(0),
+		m_CurFloorY(0),
+		m_CurFloorZ(0),
+		m_Array(a_Array),
+		m_SizeX(a_SizeX),
+		m_SizeY(a_SizeY),
+		m_SizeZ(a_SizeZ),
+		m_FracX(a_FracX),
+		m_FracY(a_FracY),
+		m_FracZ(a_FracZ)
+	{
+	}
+
+
+	/** Generates part of the output array using current m_WorkRnds[]. */
+	void Generate(
+		int a_FromX, int a_ToX,
+		int a_FromY, int a_ToY,
+		int a_FromZ, int a_ToZ
+	)
+	{
+		for (int z = a_FromZ; z < a_ToZ; z++)
+		{
+			int idxZ = z * m_SizeX * m_SizeY;
+			NOISE_DATATYPE Interp2[2][2];
+			NOISE_DATATYPE FracZ = T::coeff(m_FracZ[z]);
+			for (int x = 0; x < 2; x++)
+			{
+				for (int y = 0; y < 2; y++)
+				{
+					Interp2[x][y] = Lerp((*m_WorkRnds)[x][y][0], (*m_WorkRnds)[x][y][1], FracZ);
+				}
+			}
+			for (int y = a_FromY; y < a_ToY; y++)
+			{
+				NOISE_DATATYPE Interp[2];
+				NOISE_DATATYPE FracY = T::coeff(m_FracY[y]);
+				Interp[0] = Lerp(Interp2[0][0], Interp2[0][1], FracY);
+				Interp[1] = Lerp(Interp2[1][0], Interp2[1][1], FracY);
+				int idx = idxZ + y * m_SizeX + a_FromX;
+				for (int x = a_FromX; x < a_ToX; x++)
+				{
+					m_Array[idx++] = Lerp(Interp[0], Interp[1], T::coeff(m_FracX[x]));
+				}  // for x
+			}  // for y
+		}  // for z
+	}
+
+
+	/** Initializes m_WorkRnds[] with the specified Floor values. */
+	void InitWorkRnds(int a_FloorX, int a_FloorY, int a_FloorZ)
+	{
+		m_CurFloorX = a_FloorX;
+		m_CurFloorY = a_FloorY;
+		m_CurFloorZ = a_FloorZ;
+		(*m_WorkRnds)[0][0][0] = (NOISE_DATATYPE)m_Noise.IntNoise3D(m_CurFloorX,     m_CurFloorY,     m_CurFloorZ);
+		(*m_WorkRnds)[0][0][1] = (NOISE_DATATYPE)m_Noise.IntNoise3D(m_CurFloorX,     m_CurFloorY,     m_CurFloorZ + 1);
+		(*m_WorkRnds)[0][1][0] = (NOISE_DATATYPE)m_Noise.IntNoise3D(m_CurFloorX,     m_CurFloorY + 1, m_CurFloorZ);
+		(*m_WorkRnds)[0][1][1] = (NOISE_DATATYPE)m_Noise.IntNoise3D(m_CurFloorX,     m_CurFloorY + 1, m_CurFloorZ + 1);
+		(*m_WorkRnds)[1][0][0] = (NOISE_DATATYPE)m_Noise.IntNoise3D(m_CurFloorX + 1, m_CurFloorY,     m_CurFloorZ);
+		(*m_WorkRnds)[1][0][1] = (NOISE_DATATYPE)m_Noise.IntNoise3D(m_CurFloorX + 1, m_CurFloorY,     m_CurFloorZ + 1);
+		(*m_WorkRnds)[1][1][0] = (NOISE_DATATYPE)m_Noise.IntNoise3D(m_CurFloorX + 1, m_CurFloorY + 1, m_CurFloorZ);
+		(*m_WorkRnds)[1][1][1] = (NOISE_DATATYPE)m_Noise.IntNoise3D(m_CurFloorX + 1, m_CurFloorY + 1, m_CurFloorZ + 1);
+	}
+
+
+	/** Updates m_WorkRnds[] for the new Floor values. */
+	void Move(int a_NewFloorX, int a_NewFloorY, int a_NewFloorZ)
+	{
+		// Swap the doublebuffer:
+		int OldFloorX = m_CurFloorX;
+		int OldFloorY = m_CurFloorY;
+		int OldFloorZ = m_CurFloorZ;
+		Workspace * OldWorkRnds = m_WorkRnds;
+		m_WorkRnds = (m_WorkRnds == &m_Workspace1) ? &m_Workspace2 : &m_Workspace1;
+
+		// Reuse as much of the old workspace as possible:
+		// TODO: Try out if simply calculating all 8 elements each time is faster than this monster loop
+		int DiffX = OldFloorX - a_NewFloorX;
+		int DiffY = OldFloorY - a_NewFloorY;
+		int DiffZ = OldFloorZ - a_NewFloorZ;
+		for (int x = 0; x < 2; x++)
+		{
+			int cx = a_NewFloorX + x;
+			int OldX = x - DiffX;  // Where would this X be in the old grid?
+			for (int y = 0; y < 2; y++)
+			{
+				int cy = a_NewFloorY + y;
+				int OldY = y - DiffY;  // Where would this Y be in the old grid?
+				for (int z = 0; z < 2; z++)
+				{
+					int cz = a_NewFloorZ + z;
+					int OldZ = z - DiffZ;
+					if ((OldX >= 0) && (OldX < 2) && (OldY >= 0) && (OldY < 2) && (OldZ >= 0) && (OldZ < 2))
+					{
+						(*m_WorkRnds)[x][y][z] = (*OldWorkRnds)[OldX][OldY][OldZ];
+					}
+					else
+					{
+						(*m_WorkRnds)[x][y][z] = (NOISE_DATATYPE)m_Noise.IntNoise3D(cx, cy, cz);
+					}
+				}  // for z
+			}  // for y
+		}  // for x
+		m_CurFloorX = a_NewFloorX;
+		m_CurFloorY = a_NewFloorY;
+		m_CurFloorZ = a_NewFloorZ;
+	}
+
+protected:
+	typedef NOISE_DATATYPE Workspace[2][2][2];
+
+	/** The noise used for generating the values at integral coords. */
+	const cNoise & m_Noise;
+
+	/** The current random values; points to either m_Workspace1 or m_Workspace2 (doublebuffering) */
+	Workspace * m_WorkRnds;
+
+	/** Buffer 1 for workspace doublebuffering, used in Move() */
+	Workspace m_Workspace1;
+
+	/** Buffer 2 for workspace doublebuffering, used in Move() */
+	Workspace m_Workspace2;
+
+	/** The integral coords of the currently calculated WorkRnds[] */
+	int m_CurFloorX, m_CurFloorY, m_CurFloorZ;
+
+	/** The output array where the noise is calculated. */
+	NOISE_DATATYPE * m_Array;
+
+	/** Dimensions of the output array. */
+	int m_SizeX, m_SizeY, m_SizeZ;
+
+	/** Arrays holding the fractional values of the coords in each direction. */
+	const NOISE_DATATYPE * m_FracX;
+	const NOISE_DATATYPE * m_FracY;
+	const NOISE_DATATYPE * m_FracZ;
+} ;
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// cInterpolNoise:
+
+template <typename T>
+class cInterpolNoise
+{
+	/** Maximum size, for each direction, of the generated array. */
+	static const int MAX_SIZE = 256;
+
+public:
+	cInterpolNoise(int a_Seed):
+		m_Noise(a_Seed)
+	{
+	}
+
+
+	/** Sets a new seed for the generators. Relays the seed to the underlying noise. */
+	void SetSeed(int a_Seed)
+	{
+		m_Noise.SetSeed(a_Seed);
+	}
+
+
+	/** Fills a 2D array with the values of the noise. */
+	void Generate2D(
+		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y]
+		int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
+		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
+		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY   ///< Noise-space coords of the array in the Y direction
+	) const
+	{
+		ASSERT(a_SizeX > 0);
+		ASSERT(a_SizeY > 0);
+		ASSERT(a_SizeX < MAX_SIZE);
+		ASSERT(a_SizeY < MAX_SIZE);
+		ASSERT(a_StartX < a_EndX);
+		ASSERT(a_StartY < a_EndY);
+	
+		// Calculate the integral and fractional parts of each coord:
+		int FloorX[MAX_SIZE];
+		int FloorY[MAX_SIZE];
+		NOISE_DATATYPE FracX[MAX_SIZE];
+		NOISE_DATATYPE FracY[MAX_SIZE];
+		int SameX[MAX_SIZE];
+		int SameY[MAX_SIZE];
+		int NumSameX, NumSameY;
+		CalcFloorFrac(a_SizeX, a_StartX, a_EndX, FloorX, FracX, SameX, NumSameX);
+		CalcFloorFrac(a_SizeY, a_StartY, a_EndY, FloorY, FracY, SameY, NumSameY);
+	
+		cInterpolCell2D<T> Cell(m_Noise, a_Array, a_SizeX, a_SizeY, FracX, FracY);
+	
+		Cell.InitWorkRnds(FloorX[0], FloorY[0]);
+	
+		// Calculate query values using Cell:
+		int FromY = 0;
+		for (int y = 0; y < NumSameY; y++)
+		{
+			int ToY = FromY + SameY[y];
+			int FromX = 0;
+			int CurFloorY = FloorY[FromY];
+			for (int x = 0; x < NumSameX; x++)
+			{
+				int ToX = FromX + SameX[x];
+				Cell.Generate(FromX, ToX, FromY, ToY);
+				Cell.Move(FloorX[ToX], CurFloorY);
+				FromX = ToX;
+			}  // for x
+			Cell.Move(FloorX[0], FloorY[ToY]);
+			FromY = ToY;
+		}  // for y
+	}
+
+
+	/** Fills a 3D array with the values of the noise. */
+	void Generate3D(
+		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y + a_SizeX * a_SizeY * z]
+		int a_SizeX, int a_SizeY, int a_SizeZ,           ///< Count of the array, in each direction
+		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
+		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
+		NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ   ///< Noise-space coords of the array in the Z direction
+	) const
+	{
+		// Check params:
+		ASSERT(a_SizeX > 1);
+		ASSERT(a_SizeY > 1);
+
+		ASSERT(a_SizeX < MAX_SIZE);
+		ASSERT(a_SizeY < MAX_SIZE);
+		ASSERT(a_SizeZ < MAX_SIZE);
+		ASSERT(a_StartX < a_EndX);
+		ASSERT(a_StartY < a_EndY);
+		ASSERT(a_StartZ < a_EndZ);
+
+		// Calculate the integral and fractional parts of each coord:
+		int FloorX[MAX_SIZE];
+		int FloorY[MAX_SIZE];
+		int FloorZ[MAX_SIZE];
+		NOISE_DATATYPE FracX[MAX_SIZE];
+		NOISE_DATATYPE FracY[MAX_SIZE];
+		NOISE_DATATYPE FracZ[MAX_SIZE];
+		int SameX[MAX_SIZE];
+		int SameY[MAX_SIZE];
+		int SameZ[MAX_SIZE];
+		int NumSameX, NumSameY, NumSameZ;
+		CalcFloorFrac(a_SizeX, a_StartX, a_EndX, FloorX, FracX, SameX, NumSameX);
+		CalcFloorFrac(a_SizeY, a_StartY, a_EndY, FloorY, FracY, SameY, NumSameY);
+		CalcFloorFrac(a_SizeZ, a_StartZ, a_EndZ, FloorZ, FracZ, SameZ, NumSameZ);
+
+		cInterpolCell3D<T> Cell(
+			m_Noise, a_Array,
+			a_SizeX, a_SizeY, a_SizeZ,
+			FracX, FracY, FracZ
+		);
+	
+		Cell.InitWorkRnds(FloorX[0], FloorY[0], FloorZ[0]);
+	
+		// Calculate query values using Cell:
+		int FromZ = 0;
+		for (int z = 0; z < NumSameZ; z++)
+		{
+			int ToZ = FromZ + SameZ[z];
+			int CurFloorZ = FloorZ[FromZ];
+			int FromY = 0;
+			for (int y = 0; y < NumSameY; y++)
+			{
+				int ToY = FromY + SameY[y];
+				int CurFloorY = FloorY[FromY];
+				int FromX = 0;
+				for (int x = 0; x < NumSameX; x++)
+				{
+					int ToX = FromX + SameX[x];
+					Cell.Generate(FromX, ToX, FromY, ToY, FromZ, ToZ);
+					Cell.Move(FloorX[ToX], CurFloorY, CurFloorZ);
+					FromX = ToX;
+				}
+				Cell.Move(FloorX[0], FloorY[ToY], CurFloorZ);
+				FromY = ToY;
+			}  // for y
+			Cell.Move(FloorX[0], FloorY[0], FloorZ[ToZ]);
+			FromZ = ToZ;
+		}  // for z
+	}
+
+protected:
+
+	/** The noise used for the underlying value generation. */
+	cNoise m_Noise;
+
+
+	/** Calculates the integral and fractional parts along one axis.
+	a_Floor will receive the integral parts (array of a_Size ints).
+	a_Frac will receive the fractional parts (array of a_Size floats).
+	a_Same will receive the counts of items that have the same integral parts (array of up to a_Size ints).
+	a_NumSame will receive the count of a_Same elements (total count of different integral parts). */
+	void CalcFloorFrac(
+		int a_Size,
+		NOISE_DATATYPE a_Start, NOISE_DATATYPE a_End,
+		int * a_Floor, NOISE_DATATYPE * a_Frac,
+		int * a_Same, int & a_NumSame
+	) const
+	{
+		ASSERT(a_Size > 0);
+
+		// Calculate the floor and frac values:
+		NOISE_DATATYPE val = a_Start;
+		NOISE_DATATYPE dif = (a_End - a_Start) / (a_Size - 1);
+		for (int i = 0; i < a_Size; i++)
+		{
+			a_Floor[i] = FAST_FLOOR(val);
+			a_Frac[i] = val - a_Floor[i];
+			val += dif;
+		}
+
+		// Mark up the same floor values into a_Same / a_NumSame:
+		int CurFloor = a_Floor[0];
+		int LastSame = 0;
+		a_NumSame = 0;
+		for (int i = 1; i < a_Size; i++)
+		{
+			if (a_Floor[i] != CurFloor)
+			{
+				a_Same[a_NumSame] = i - LastSame;
+				LastSame = i;
+				a_NumSame += 1;
+				CurFloor = a_Floor[i];
+			}
+		}  // for i - a_Floor[]
+		if (LastSame < a_Size)
+		{
+			a_Same[a_NumSame] = a_Size - LastSame;
+			a_NumSame += 1;
+		}
+	}
+};
+
+
+
+
+
+/** A fifth-degree curve for interpolating.
+Implemented as a functor for better chance of inlining. */
+struct Interp5Deg
+{
+	static NOISE_DATATYPE coeff(NOISE_DATATYPE a_Val)
+	{
+		return a_Val * a_Val * a_Val * (a_Val * (a_Val * 6 - 15) + 10);
+	}
+};
+
+typedef cInterpolNoise<Interp5Deg> cInterp5DegNoise;
+
+
+
diff --git a/src/Noise.cpp b/src/Noise/Noise.cpp
index 8fcfe2920..509be7d6c 100644
--- a/src/Noise.cpp
+++ b/src/Noise/Noise.cpp
@@ -2,6 +2,7 @@
 #include "Globals.h"  // NOTE: MSVC stupidness requires this to be the same across all modules
 
 #include "Noise.h"
+#include "OSSupport/Timer.h"
 
 #define FAST_FLOOR(x) (((x) < 0) ? (((int)x) - 1) : ((int)x))
 
@@ -9,10 +10,110 @@
 
 
 
+#if 0
+/** cImprovedPerlin noise test suite:
+- Generate a rather large 2D and 3D noise array and output it to a file
+- Compare performance of cCubicNoise and cImprovedNoise, both in single-value and 3D-array usages */
+static class cImprovedPerlinNoiseTest
+{
+public:
+	cImprovedPerlinNoiseTest(void)
+	{
+		printf("Performing Improved Perlin Noise tests...\n");
+		TestImage();
+		TestSpeed();
+		TestSpeedArr();
+		printf("Improved Perlin Noise tests complete.\n");
+	}
+
+
+	/** Tests the noise by generating 2D and 3D images and dumping them to files. */
+	void TestImage(void)
+	{
+		static const int SIZE_X = 256;
+		static const int SIZE_Y = 256;
+		static const int SIZE_Z = 16;
+
+		cImprovedNoise noise(1);
+		std::unique_ptr<NOISE_DATATYPE[]> arr(new NOISE_DATATYPE[SIZE_X * SIZE_Y * SIZE_Z]);
+		noise.Generate3D(arr.get(), SIZE_X, SIZE_Y, SIZE_Z, 0, 14, 0, 14, 0, 14);
+		Debug3DNoise(arr.get(), SIZE_X, SIZE_Y, SIZE_Z, "ImprovedPerlinNoiseTest3D", 128);
+		noise.Generate2D(arr.get(), SIZE_X, SIZE_Y, 0, 14, 15, 28);
+		Debug2DNoise(arr.get(), SIZE_X, SIZE_Y, "ImprovedPerlinNoiseTest2D", 128);
+	}
+
+
+	/** Tests the speeds of cImprovedPerlin and cCubicNoise when generating individual values. */
+	void TestSpeed(void)
+	{
+		cImprovedNoise improvedNoise(1);
+		cNoise         noise(1);
+		cTimer timer;
+
+		// Measure the improvedNoise:
+		NOISE_DATATYPE sum = 0;
+		long long start = timer.GetNowTime();
+		for (int i = 0; i < 100000000; i++)
+		{
+			sum += improvedNoise.GetValueAt(i, 0, -i);
+		}
+		long long finish = timer.GetNowTime();
+		printf("cImprovedNoise took %.2f seconds; total is %f.\n", static_cast<float>(finish - start) / 1000.0f, sum);
+
+		// Measure the cubicNoise:
+		sum = 0;
+		start = timer.GetNowTime();
+		for (int i = 0; i < 100000000; i++)
+		{
+			sum += noise.IntNoise3D(i, 0, -i);
+		}
+		finish = timer.GetNowTime();
+		printf("cCubicNoise took %.2f seconds; total is %f.\n", static_cast<float>(finish - start) / 1000.0f, sum);
+	}
+
+
+	/** Tests the speeds of cImprovedPerlin and cCubicNoise when generating arrays. */
+	void TestSpeedArr(void)
+	{
+		static const int SIZE_X = 256;
+		static const int SIZE_Y = 256;
+		static const int SIZE_Z = 16;
+
+		std::unique_ptr<NOISE_DATATYPE[]> arr(new NOISE_DATATYPE[SIZE_X * SIZE_Y * SIZE_Z]);
+		cTimer timer;
+		cImprovedNoise improvedNoise(1);
+		cCubicNoise    cubicNoise(1);
+
+		// Measure the improvedNoise:
+		long long start = timer.GetNowTime();
+		for (int i = 0; i < 40; i++)
+		{
+			improvedNoise.Generate3D(arr.get(), SIZE_X, SIZE_Y, SIZE_Z, 0, 14, 0, 14, 0, 14);
+		}
+		long long finish = timer.GetNowTime();
+		printf("cImprovedNoise(arr) took %.2f seconds.\n", static_cast<float>(finish - start) / 1000.0f);
+
+		// Measure the cubicNoise:
+		start = timer.GetNowTime();
+		for (int i = 0; i < 40; i++)
+		{
+			cubicNoise.Generate3D(arr.get(), SIZE_X, SIZE_Y, SIZE_Z, 0, 14, 0, 14, 0, 14);
+		}
+		finish = timer.GetNowTime();
+		printf("cCubicNoise(arr) took %.2f seconds.\n", static_cast<float>(finish - start) / 1000.0f);
+	}
+} g_Test;
+
+#endif
+
+
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // Globals:
 
-void Debug3DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, int a_SizeZ, const AString & a_FileNameBase)
+void Debug3DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, int a_SizeZ, const AString & a_FileNameBase, NOISE_DATATYPE a_Coeff)
 {
 	const int BUF_SIZE = 512;
 	ASSERT(a_SizeX <= BUF_SIZE);  // Just stretch it, if needed
@@ -29,7 +130,7 @@ void Debug3DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, int
 				unsigned char buf[BUF_SIZE];
 				for (int x = 0; x < a_SizeX; x++)
 				{
-					buf[x] = (unsigned char)(std::min(255, std::max(0, (int)(128 + 32 * a_Noise[idx++]))));
+					buf[x] = static_cast<unsigned char>(Clamp((int)(128 + a_Coeff * a_Noise[idx++]), 0, 255));
 				}
 				f1.Write(buf, a_SizeX);
 			}  // for y
@@ -50,7 +151,7 @@ void Debug3DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, int
 				unsigned char buf[BUF_SIZE];
 				for (int x = 0; x < a_SizeX; x++)
 				{
-					buf[x] = (unsigned char)(std::min(255, std::max(0, (int)(128 + 32 * a_Noise[idx++]))));
+					buf[x] = static_cast<unsigned char>(Clamp((int)(128 + a_Coeff * a_Noise[idx++]), 0, 255));
 				}
 				f2.Write(buf, a_SizeX);
 			}  // for z
@@ -65,7 +166,7 @@ void Debug3DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, int
 
 
 
-void Debug2DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, const AString & a_FileNameBase)
+void Debug2DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, const AString & a_FileNameBase, NOISE_DATATYPE a_Coeff)
 {
 	const int BUF_SIZE = 512;
 	ASSERT(a_SizeX <= BUF_SIZE);  // Just stretch it, if needed
@@ -79,7 +180,7 @@ void Debug2DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, cons
 			unsigned char buf[BUF_SIZE];
 			for (int x = 0; x < a_SizeX; x++)
 			{
-				buf[x] = (unsigned char)(std::min(255, std::max(0, (int)(128 + 32 * a_Noise[idx++]))));
+				buf[x] = static_cast<unsigned char>(Clamp((int)(128 + a_Coeff * a_Noise[idx++]), 0, 255));
 			}
 			f1.Write(buf, a_SizeX);
 		}  // for y
@@ -594,13 +695,6 @@ NOISE_DATATYPE cNoise::CubicNoise3D(NOISE_DATATYPE a_X, NOISE_DATATYPE a_Y, NOIS
 ////////////////////////////////////////////////////////////////////////////////
 // cCubicNoise:
 
-#ifdef _DEBUG
-	int cCubicNoise::m_NumSingleX = 0;
-	int cCubicNoise::m_NumSingleXY = 0;
-	int cCubicNoise::m_NumSingleY = 0;
-	int cCubicNoise::m_NumCalls = 0;
-#endif  // _DEBUG
-
 cCubicNoise::cCubicNoise(int a_Seed) :
 	m_Noise(a_Seed)
 {
@@ -639,23 +733,6 @@ void cCubicNoise::Generate2D(
 	
 	Cell.InitWorkRnds(FloorX[0], FloorY[0]);
 	
-	#ifdef _DEBUG
-		// Statistics on the noise-space coords:
-		if (NumSameX == 1)
-		{
-			m_NumSingleX++;
-			if (NumSameY == 1)
-			{
-				m_NumSingleXY++;
-			}
-		}
-		if (NumSameY == 1)
-		{
-			m_NumSingleY++;
-		}
-		m_NumCalls++;
-	#endif  // _DEBUG
-	
 	// Calculate query values using Cell:
 	int FromY = 0;
 	for (int y = 0; y < NumSameY; y++)
@@ -792,101 +869,28 @@ void cCubicNoise::CalcFloorFrac(
 
 
 ////////////////////////////////////////////////////////////////////////////////
-// cPerlinNoise:
-
-cPerlinNoise::cPerlinNoise(void) :
-	m_Seed(0)
-{
-}
-
-
-
+// cImprovedNoise:
 
-
-cPerlinNoise::cPerlinNoise(int a_Seed) :
-	m_Seed(a_Seed)
-{
-}
-
-
-
-
-
-void cPerlinNoise::SetSeed(int a_Seed)
-{
-	m_Seed = a_Seed;
-}
-
-
-
-
-
-void cPerlinNoise::AddOctave(float a_Frequency, float a_Amplitude)
-{
-	m_Octaves.push_back(cOctave(m_Seed * ((int)m_Octaves.size() + 4) * 4 + 1024, a_Frequency, a_Amplitude));
-}
-
-
-
-
-
-void cPerlinNoise::Generate2D(
-	NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y]
-	int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
-	NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
-	NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-	NOISE_DATATYPE * a_Workspace                     ///< Workspace that this function can use and trash
-) const
+cImprovedNoise::cImprovedNoise(int a_Seed)
 {
-	if (m_Octaves.empty())
-	{
-		// No work to be done
-		ASSERT(!"Perlin: No octaves to generate!");
-		return;
-	}
-	
-	bool ShouldFreeWorkspace = (a_Workspace == nullptr);
-	int ArrayCount = a_SizeX * a_SizeY;
-	if (ShouldFreeWorkspace)
-	{
-		a_Workspace = new NOISE_DATATYPE[ArrayCount];
-	}
-	
-	// Generate the first octave directly into array:
-	const cOctave & FirstOctave = m_Octaves.front();
-	
-	FirstOctave.m_Noise.Generate2D(
-		a_Workspace, a_SizeX, a_SizeY,
-		a_StartX * FirstOctave.m_Frequency, a_EndX * FirstOctave.m_Frequency,
-		a_StartY * FirstOctave.m_Frequency, a_EndY * FirstOctave.m_Frequency
-	);
-	NOISE_DATATYPE Amplitude = FirstOctave.m_Amplitude;
-	for (int i = 0; i < ArrayCount; i++)
+	// Initialize the permutations with identity:
+	for (int i = 0; i < 256; i++)
 	{
-		a_Array[i] = a_Workspace[i] * Amplitude;
+		m_Perm[i] = i;
 	}
-	
-	// Add each octave:
-	for (cOctaves::const_iterator itr = m_Octaves.begin() + 1, end = m_Octaves.end(); itr != end; ++itr)
+
+	// Randomize the permutation table - swap each element with a random other element:
+	cNoise noise(a_Seed);
+	for (int i = 0; i < 256; i++)
 	{
-		// Generate cubic noise for the octave:
-		itr->m_Noise.Generate2D(
-			a_Workspace, a_SizeX, a_SizeY,
-			a_StartX * itr->m_Frequency, a_EndX * itr->m_Frequency,
-			a_StartY * itr->m_Frequency, a_EndY * itr->m_Frequency
-		);
-		// Add the cubic noise into the output:
-		NOISE_DATATYPE Amplitude = itr->m_Amplitude;
-		for (int i = 0; i < ArrayCount; i++)
-		{
-			a_Array[i] += a_Workspace[i] * Amplitude;
-		}
+		int rnd = (noise.IntNoise1DInt(i) / 7) % 256;
+		std::swap(m_Perm[i], m_Perm[rnd]);
 	}
-	
-	if (ShouldFreeWorkspace)
+
+	// Copy the lower 256 entries into upper 256 entries:
+	for (int i = 0; i < 256; i++)
 	{
-		delete[] a_Workspace;
-		a_Workspace = nullptr;
+		m_Perm[i + 256] = m_Perm[i];
 	}
 }
 
@@ -894,239 +898,132 @@ void cPerlinNoise::Generate2D(
 
 
 
-void cPerlinNoise::Generate3D(
-	NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y + a_SizeX * a_SizeY * z]
-	int a_SizeX, int a_SizeY, int a_SizeZ,           ///< Count of the array, in each direction
-	NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
-	NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-	NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ,  ///< Noise-space coords of the array in the Z direction
-	NOISE_DATATYPE * a_Workspace                     ///< Workspace that this function can use and trash
+void cImprovedNoise::Generate2D(
+	NOISE_DATATYPE * a_Array,
+	int a_SizeX, int a_SizeY,
+	NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,
+	NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY
 ) const
 {
-	if (m_Octaves.empty())
-	{
-		// No work to be done
-		ASSERT(!"Perlin: No octaves to generate!");
-		return;
-	}
-	
-	bool ShouldFreeWorkspace = (a_Workspace == nullptr);
-	int ArrayCount = a_SizeX * a_SizeY * a_SizeZ;
-	if (ShouldFreeWorkspace)
+	size_t idx = 0;
+	for (int y = 0; y < a_SizeY; y++)
 	{
-		a_Workspace = new NOISE_DATATYPE[ArrayCount];
-	}
-	
-	// Generate the first octave directly into array:
-	const cOctave & FirstOctave = m_Octaves.front();
-
-	FirstOctave.m_Noise.Generate3D(
-		a_Workspace, a_SizeX, a_SizeY, a_SizeZ,
-		a_StartX * FirstOctave.m_Frequency, a_EndX * FirstOctave.m_Frequency,
-		a_StartY * FirstOctave.m_Frequency, a_EndY * FirstOctave.m_Frequency,
-		a_StartZ * FirstOctave.m_Frequency, a_EndZ * FirstOctave.m_Frequency
-	);
-	NOISE_DATATYPE Amplitude = FirstOctave.m_Amplitude;
-	for (int i = 0; i < ArrayCount; i++)
-	{
-		a_Array[i] = a_Workspace[i] * Amplitude;
-	}
-	
-	// Add each octave:
-	for (cOctaves::const_iterator itr = m_Octaves.begin() + 1, end = m_Octaves.end(); itr != end; ++itr)
-	{
-		// Generate cubic noise for the octave:
-		itr->m_Noise.Generate3D(
-			a_Workspace, a_SizeX, a_SizeY, a_SizeZ,
-			a_StartX * itr->m_Frequency, a_EndX * itr->m_Frequency,
-			a_StartY * itr->m_Frequency, a_EndY * itr->m_Frequency,
-			a_StartZ * itr->m_Frequency, a_EndZ * itr->m_Frequency
-		);
-		// Add the cubic noise into the output:
-		NOISE_DATATYPE Amplitude = itr->m_Amplitude;
-		for (int i = 0; i < ArrayCount; i++)
+		NOISE_DATATYPE ratioY = static_cast<NOISE_DATATYPE>(y) / (a_SizeY - 1);
+		NOISE_DATATYPE noiseY = Lerp(a_StartY, a_EndY, ratioY);
+		int noiseYInt = FAST_FLOOR(noiseY);
+		int yCoord = noiseYInt & 255;
+		NOISE_DATATYPE noiseYFrac = noiseY - noiseYInt;
+		NOISE_DATATYPE fadeY = Fade(noiseYFrac);
+		for (int x = 0; x < a_SizeX; x++)
 		{
-			a_Array[i] += a_Workspace[i] * Amplitude;
-		}
-	}
-	
-	if (ShouldFreeWorkspace)
-	{
-		delete[] a_Workspace;
-		a_Workspace = nullptr;
-	}
-}
-
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-// cRidgedMultiNoise:
-
-cRidgedMultiNoise::cRidgedMultiNoise(void) :
-	m_Seed(0)
-{
-}
-
-
-
-
-
-cRidgedMultiNoise::cRidgedMultiNoise(int a_Seed) :
-	m_Seed(a_Seed)
-{
-}
-
-
-
-
-
-void cRidgedMultiNoise::SetSeed(int a_Seed)
-{
-	m_Seed = a_Seed;
-}
-
-
-
-
-
-void cRidgedMultiNoise::AddOctave(float a_Frequency, float a_Amplitude)
-{
-	m_Octaves.push_back(cOctave(m_Seed * ((int)m_Octaves.size() + 4) * 4 + 1024, a_Frequency, a_Amplitude));
+			NOISE_DATATYPE ratioX = static_cast<NOISE_DATATYPE>(x) / (a_SizeX - 1);
+			NOISE_DATATYPE noiseX = Lerp(a_StartX, a_EndX, ratioX);
+			int noiseXInt = FAST_FLOOR(noiseX);
+			int xCoord = noiseXInt & 255;
+			NOISE_DATATYPE noiseXFrac = noiseX - noiseXInt;
+			NOISE_DATATYPE fadeX = Fade(noiseXFrac);
+
+			// Hash the coordinates:
+			int A  = m_Perm[xCoord] + yCoord;
+			int AA = m_Perm[A];
+			int AB = m_Perm[A + 1];
+			int B  = m_Perm[xCoord + 1] + yCoord;
+			int BA = m_Perm[B];
+			int BB = m_Perm[B + 1];
+
+			// Lerp the gradients:
+			a_Array[idx++] = Lerp(
+				Lerp(Grad(m_Perm[AA], noiseXFrac, noiseYFrac,     0), Grad(m_Perm[BA], noiseXFrac - 1, noiseYFrac,     0), fadeX),
+				Lerp(Grad(m_Perm[AB], noiseXFrac, noiseYFrac - 1, 0), Grad(m_Perm[BB], noiseXFrac - 1, noiseYFrac - 1, 0), fadeX),
+				fadeY
+			);
+		}  // for x
+	}  // for y
 }
 
 
 
 
 
-void cRidgedMultiNoise::Generate2D(
-	NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y]
-	int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
-	NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
-	NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-	NOISE_DATATYPE * a_Workspace                     ///< Workspace that this function can use and trash
+void cImprovedNoise::Generate3D(
+	NOISE_DATATYPE * a_Array,
+	int a_SizeX, int a_SizeY, int a_SizeZ,
+	NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,
+	NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,
+	NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ
 ) const
 {
-	if (m_Octaves.empty())
-	{
-		// No work to be done
-		ASSERT(!"RidgedMulti: No octaves to generate!");
-		return;
-	}
-	
-	bool ShouldFreeWorkspace = (a_Workspace == nullptr);
-	int ArrayCount = a_SizeX * a_SizeY;
-	if (ShouldFreeWorkspace)
-	{
-		a_Workspace = new NOISE_DATATYPE[ArrayCount];
-	}
-	
-	// Generate the first octave directly into array:
-	const cOctave & FirstOctave = m_Octaves.front();
-	
-	FirstOctave.m_Noise.Generate2D(
-		a_Workspace, a_SizeX, a_SizeY,
-		a_StartX * FirstOctave.m_Frequency, a_EndX * FirstOctave.m_Frequency,
-		a_StartY * FirstOctave.m_Frequency, a_EndY * FirstOctave.m_Frequency
-	);
-	NOISE_DATATYPE Amplitude = FirstOctave.m_Amplitude;
-	for (int i = 0; i < ArrayCount; i++)
+	size_t idx = 0;
+	for (int z = 0; z < a_SizeZ; z++)
 	{
-		a_Array[i] = fabs(a_Workspace[i] * Amplitude);
-	}
-	
-	// Add each octave:
-	for (cOctaves::const_iterator itr = m_Octaves.begin() + 1, end = m_Octaves.end(); itr != end; ++itr)
-	{
-		// Generate cubic noise for the octave:
-		itr->m_Noise.Generate2D(
-			a_Workspace, a_SizeX, a_SizeY,
-			a_StartX * itr->m_Frequency, a_EndX * itr->m_Frequency,
-			a_StartY * itr->m_Frequency, a_EndY * itr->m_Frequency
-		);
-		// Add the cubic noise into the output:
-		NOISE_DATATYPE Amplitude = itr->m_Amplitude;
-		for (int i = 0; i < ArrayCount; i++)
+		NOISE_DATATYPE ratioZ = static_cast<NOISE_DATATYPE>(z) / (a_SizeZ - 1);
+		NOISE_DATATYPE noiseZ = Lerp(a_StartZ, a_EndZ, ratioZ);
+		int noiseZInt = FAST_FLOOR(noiseZ);
+		int zCoord = noiseZInt & 255;
+		NOISE_DATATYPE noiseZFrac = noiseZ - noiseZInt;
+		NOISE_DATATYPE fadeZ = Fade(noiseZFrac);
+		for (int y = 0; y < a_SizeY; y++)
 		{
-			a_Array[i] += fabs(a_Workspace[i] * Amplitude);
-		}
-	}
-	
-	if (ShouldFreeWorkspace)
-	{
-		delete[] a_Workspace;
-		a_Workspace = nullptr;
-	}
+			NOISE_DATATYPE ratioY = static_cast<NOISE_DATATYPE>(y) / (a_SizeY - 1);
+			NOISE_DATATYPE noiseY = Lerp(a_StartY, a_EndY, ratioY);
+			int noiseYInt = FAST_FLOOR(noiseY);
+			int yCoord = noiseYInt & 255;
+			NOISE_DATATYPE noiseYFrac = noiseY - noiseYInt;
+			NOISE_DATATYPE fadeY = Fade(noiseYFrac);
+			for (int x = 0; x < a_SizeX; x++)
+			{
+				NOISE_DATATYPE ratioX = static_cast<NOISE_DATATYPE>(x) / (a_SizeX - 1);
+				NOISE_DATATYPE noiseX = Lerp(a_StartX, a_EndX, ratioX);
+				int noiseXInt = FAST_FLOOR(noiseX);
+				int xCoord = noiseXInt & 255;
+				NOISE_DATATYPE noiseXFrac = noiseX - noiseXInt;
+				NOISE_DATATYPE fadeX = Fade(noiseXFrac);
+
+				// Hash the coordinates:
+				int A  = m_Perm[xCoord] + yCoord;
+				int AA = m_Perm[A] + zCoord;
+				int AB = m_Perm[A + 1] + zCoord;
+				int B  = m_Perm[xCoord + 1] + yCoord;
+				int BA = m_Perm[B] + zCoord;
+				int BB = m_Perm[B + 1] + zCoord;
+
+				// Lerp the gradients:
+				// TODO: This may be optimized by swapping the coords and recalculating most lerps only "once every x"
+				a_Array[idx++] = Lerp(
+					Lerp(
+						Lerp(Grad(m_Perm[AA], noiseXFrac, noiseYFrac,     noiseZFrac), Grad(m_Perm[BA], noiseXFrac - 1, noiseYFrac,     noiseZFrac), fadeX),
+						Lerp(Grad(m_Perm[AB], noiseXFrac, noiseYFrac - 1, noiseZFrac), Grad(m_Perm[BB], noiseXFrac - 1, noiseYFrac - 1, noiseZFrac), fadeX),
+						fadeY
+					),
+					Lerp(
+						Lerp(Grad(m_Perm[AA + 1], noiseXFrac, noiseYFrac,     noiseZFrac - 1), Grad(m_Perm[BA + 1], noiseXFrac - 1, noiseYFrac,     noiseZFrac - 1), fadeX),
+						Lerp(Grad(m_Perm[AB + 1], noiseXFrac, noiseYFrac - 1, noiseZFrac - 1), Grad(m_Perm[BB + 1], noiseXFrac - 1, noiseYFrac - 1, noiseZFrac - 1), fadeX),
+						fadeY
+					),
+					fadeZ
+				);
+			}  // for x
+		}  // for y
+	}  // for z
 }
 
 
 
 
 
-void cRidgedMultiNoise::Generate3D(
-	NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y + a_SizeX * a_SizeY * z]
-	int a_SizeX, int a_SizeY, int a_SizeZ,           ///< Count of the array, in each direction
-	NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
-	NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-	NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ,  ///< Noise-space coords of the array in the Z direction
-	NOISE_DATATYPE * a_Workspace                     ///< Workspace that this function can use and trash
-) const
+NOISE_DATATYPE cImprovedNoise::GetValueAt(int a_X, int a_Y, int a_Z)
 {
-	if (m_Octaves.empty())
-	{
-		// No work to be done
-		ASSERT(!"RidgedMulti: No octaves to generate!");
-		return;
-	}
-	
-	bool ShouldFreeWorkspace = (a_Workspace == nullptr);
-	int ArrayCount = a_SizeX * a_SizeY * a_SizeZ;
-	if (ShouldFreeWorkspace)
-	{
-		a_Workspace = new NOISE_DATATYPE[ArrayCount];
-	}
-	
-	// Generate the first octave directly into array:
-	const cOctave & FirstOctave = m_Octaves.front();
-
-	FirstOctave.m_Noise.Generate3D(
-		a_Workspace, a_SizeX, a_SizeY, a_SizeZ,
-		a_StartX * FirstOctave.m_Frequency, a_EndX * FirstOctave.m_Frequency,
-		a_StartY * FirstOctave.m_Frequency, a_EndY * FirstOctave.m_Frequency,
-		a_StartZ * FirstOctave.m_Frequency, a_EndZ * FirstOctave.m_Frequency
-	);
-	NOISE_DATATYPE Amplitude = FirstOctave.m_Amplitude;
-	for (int i = 0; i < ArrayCount; i++)
-	{
-		a_Array[i] = a_Workspace[i] * Amplitude;
-	}
-	
-	// Add each octave:
-	for (cOctaves::const_iterator itr = m_Octaves.begin() + 1, end = m_Octaves.end(); itr != end; ++itr)
-	{
-		// Generate cubic noise for the octave:
-		itr->m_Noise.Generate3D(
-			a_Workspace, a_SizeX, a_SizeY, a_SizeZ,
-			a_StartX * itr->m_Frequency, a_EndX * itr->m_Frequency,
-			a_StartY * itr->m_Frequency, a_EndY * itr->m_Frequency,
-			a_StartZ * itr->m_Frequency, a_EndZ * itr->m_Frequency
-		);
-		// Add the cubic noise into the output:
-		NOISE_DATATYPE Amplitude = itr->m_Amplitude;
-		for (int i = 0; i < ArrayCount; i++)
-		{
-			a_Array[i] += a_Workspace[i] * Amplitude;
-		}
-	}
-	
-	if (ShouldFreeWorkspace)
-	{
-		delete[] a_Workspace;
-		a_Workspace = nullptr;
-	}
+	// Hash the coordinates:
+	a_X = a_X & 255;
+	a_Y = a_Y & 255;
+	a_Z = a_Z & 255;
+	int A  = m_Perm[a_X] + a_Y;
+	int AA = m_Perm[A] + a_Z;
+
+	return Grad(m_Perm[AA], 1, 1, 1);
 }
 
 
 
 
+
diff --git a/src/Noise.h b/src/Noise/Noise.h
index b7a90d5b7..323194bfd 100644
--- a/src/Noise.h
+++ b/src/Noise/Noise.h
@@ -7,22 +7,11 @@
 
 #include <cmath>
 
+/** The datatype used by all the noise generators. */
+typedef float NOISE_DATATYPE;
 
-
-
-
-// Some settings
-#define NOISE_DATATYPE float
-
-
-
-
-
-#ifdef _MSC_VER
-	#define INLINE __forceinline
-#else
-	#define INLINE inline
-#endif
+#include "OctavedNoise.h"
+#include "RidgedNoise.h"
 
 
 
@@ -35,20 +24,20 @@ public:
 	cNoise(const cNoise & a_Noise);
 
 	// The following functions, if not marked INLINE, are about 20 % slower
-	INLINE NOISE_DATATYPE IntNoise1D(int a_X) const;
-	INLINE NOISE_DATATYPE IntNoise2D(int a_X, int a_Y) const;
-	INLINE NOISE_DATATYPE IntNoise3D(int a_X, int a_Y, int a_Z) const;
+	inline NOISE_DATATYPE IntNoise1D(int a_X) const;
+	inline NOISE_DATATYPE IntNoise2D(int a_X, int a_Y) const;
+	inline NOISE_DATATYPE IntNoise3D(int a_X, int a_Y, int a_Z) const;
 
 	// Return a float number in the specified range:
-	INLINE NOISE_DATATYPE IntNoise2DInRange(int a_X, int a_Y, float a_Min, float a_Max) const
+	inline NOISE_DATATYPE IntNoise2DInRange(int a_X, int a_Y, float a_Min, float a_Max) const
 	{
 		return a_Min + std::abs(IntNoise2D(a_X, a_Y)) * (a_Max - a_Min);
 	}
 
 	// Note: These functions have a mod8-irregular chance - each of the mod8 remainders has different chance of occurrence. Divide by 8 to rectify.
-	INLINE int IntNoise1DInt(int a_X) const;
-	INLINE int IntNoise2DInt(int a_X, int a_Y) const;
-	INLINE int IntNoise3DInt(int a_X, int a_Y, int a_Z) const;
+	inline int IntNoise1DInt(int a_X) const;
+	inline int IntNoise2DInt(int a_X, int a_Y) const;
+	inline int IntNoise3DInt(int a_X, int a_Y, int a_Z) const;
 
 	NOISE_DATATYPE LinearNoise1D(NOISE_DATATYPE a_X) const;
 	NOISE_DATATYPE CosineNoise1D(NOISE_DATATYPE a_X) const;
@@ -61,9 +50,9 @@ public:
 
 	void SetSeed(int a_Seed) { m_Seed = a_Seed; }
 
-	INLINE static NOISE_DATATYPE CubicInterpolate (NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_C, NOISE_DATATYPE a_D, NOISE_DATATYPE a_Pct);
-	INLINE static NOISE_DATATYPE CosineInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct);
-	INLINE static NOISE_DATATYPE LinearInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct);
+	inline static NOISE_DATATYPE CubicInterpolate (NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_C, NOISE_DATATYPE a_D, NOISE_DATATYPE a_Pct);
+	inline static NOISE_DATATYPE CosineInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct);
+	inline static NOISE_DATATYPE LinearInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B, NOISE_DATATYPE a_Pct);
 
 private:
 	int m_Seed;
@@ -76,19 +65,15 @@ private:
 class cCubicNoise
 {
 public:
-	static const int MAX_SIZE = 512;  ///< Maximum size of each dimension of the query arrays.
+	/** Maximum size of each dimension of the query arrays. */
+	static const int MAX_SIZE = 512;
 	
 	
+	/** Creates a new instance with the specified seed. */
 	cCubicNoise(int a_Seed);
 	
 	
-	void Generate1D(
-		NOISE_DATATYPE * a_Array,                        ///< Array to generate into
-		int a_SizeX,                                     ///< Count of the array
-		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX   ///< Noise-space coords of the array
-	) const;
-	
-	
+	/** Fills a 2D array with the values of the noise. */
 	void Generate2D(
 		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y]
 		int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
@@ -97,6 +82,7 @@ public:
 	) const;
 	
 	
+	/** Fills a 3D array with the values of the noise. */
 	void Generate3D(
 		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y + a_SizeX * a_SizeY * z]
 		int a_SizeX, int a_SizeY, int a_SizeZ,           ///< Count of the array, in each direction
@@ -106,163 +92,87 @@ public:
 	) const;
 	
 protected:
-	typedef NOISE_DATATYPE Workspace1D[4];
-	typedef NOISE_DATATYPE Workspace2D[4][4];
-	
-	cNoise m_Noise;  // Used for integral rnd values
-
-	#ifdef _DEBUG
-		// Statistics on the noise-space coords:
-		static int m_NumSingleX;
-		static int m_NumSingleXY;
-		static int m_NumSingleY;
-		static int m_NumCalls;
-	#endif  // _DEBUG
 	
-	/// Calculates the integral and fractional parts along one axis.
+	/** Noise used for integral random values. */
+	cNoise m_Noise;
+
+
+	/** Calculates the integral and fractional parts along one axis.
+	a_Floor will receive the integral parts (array of a_Size ints).
+	a_Frac will receive the fractional parts (array of a_Size floats).
+	a_Same will receive the counts of items that have the same integral parts (array of up to a_Size ints).
+	a_NumSame will receive the count of a_Same elements (total count of different integral parts). */
 	void CalcFloorFrac(
 		int a_Size,
 		NOISE_DATATYPE a_Start, NOISE_DATATYPE a_End,
 		int * a_Floor, NOISE_DATATYPE * a_Frac,
 		int * a_Same, int & a_NumSame
 	) const;
-	
-	void UpdateWorkRnds2DX(
-		Workspace2D & a_WorkRnds,
-		Workspace1D & a_Interps,
-		int a_LastFloorX, int a_NewFloorX,
-		int a_FloorY,
-		NOISE_DATATYPE a_FractionY
-	) const;
 } ;
 
 
 
 
 
-class cPerlinNoise
+/** Improved noise, as described by Ken Perlin: http://mrl.nyu.edu/~perlin/paper445.pdf
+Implementation adapted from Perlin's Java implementation: http://mrl.nyu.edu/~perlin/noise/ */
+class cImprovedNoise
 {
 public:
-	cPerlinNoise(void);
-	cPerlinNoise(int a_Seed);
-	
-	
-	void SetSeed(int a_Seed);
-	
-	void AddOctave(NOISE_DATATYPE a_Frequency, NOISE_DATATYPE a_Amplitude);
-	
-	void Generate1D(
-		NOISE_DATATYPE * a_Array,                        ///< Array to generate into
-		int a_SizeX,                                     ///< Count of the array
-		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array
-		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
-	) const;
-	
-	
+	/** Constructs a new instance of the noise obbject.
+	Note that this operation is quite expensive (the permutation array being constructed). */
+	cImprovedNoise(int a_Seed);
+
+
+	/** Fills a 2D array with the values of the noise. */
 	void Generate2D(
 		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y]
 		int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
 		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
-		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
+		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY   ///< Noise-space coords of the array in the Y direction
 	) const;
 	
 	
+	/** Fills a 3D array with the values of the noise. */
 	void Generate3D(
 		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y + a_SizeX * a_SizeY * z]
 		int a_SizeX, int a_SizeY, int a_SizeZ,           ///< Count of the array, in each direction
 		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
 		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-		NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ,  ///< Noise-space coords of the array in the Z direction
-		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
+		NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ   ///< Noise-space coords of the array in the Z direction
 	) const;
-	
+
+	/** Returns the value at the specified integral coords. Used for raw speed measurement. */
+	NOISE_DATATYPE GetValueAt(int a_X, int a_Y, int a_Z);
+
 protected:
-	class cOctave
+
+	/** The permutation table used by the noise function. Initialized using seed. */
+	int m_Perm[512];
+
+
+	/** Calculates the fade curve, 6 * t^5 - 15 * t^4 + 10 * t^3. */
+	inline static NOISE_DATATYPE Fade(NOISE_DATATYPE a_T)
 	{
-	public:
-		cCubicNoise m_Noise;
-		
-		NOISE_DATATYPE m_Frequency;  // Coord multiplier
-		NOISE_DATATYPE m_Amplitude;  // Value multiplier
-		
-		cOctave(int a_Seed, NOISE_DATATYPE a_Frequency, NOISE_DATATYPE a_Amplitude) :
-			m_Noise(a_Seed),
-			m_Frequency(a_Frequency),
-			m_Amplitude(a_Amplitude)
-		{
-		}
-	} ;
-	
-	typedef std::vector<cOctave> cOctaves;
-	
-	int      m_Seed;
-	cOctaves m_Octaves;
-} ;
+		return a_T * a_T * a_T * (a_T * (a_T * 6 - 15) + 10);
+	}
 
+	/** Returns the gradient value based on the hash. */
+	inline static NOISE_DATATYPE Grad(int a_Hash, NOISE_DATATYPE a_X, NOISE_DATATYPE a_Y, NOISE_DATATYPE a_Z)
+	{
+		int hash = a_Hash % 16;
+		NOISE_DATATYPE u = (hash < 8) ? a_X : a_Y;
+		NOISE_DATATYPE v = (hash < 4) ? a_Y : (((hash == 12) || (hash == 14)) ? a_X : a_Z);
+		return (((hash & 1) == 0) ? u : -u) + (((hash & 2) == 0) ? v : -v);
+	}
+};
 
 
 
 
-class cRidgedMultiNoise
-{
-public:
-	cRidgedMultiNoise(void);
-	cRidgedMultiNoise(int a_Seed);
-	
-	
-	void SetSeed(int a_Seed);
-	
-	void AddOctave(NOISE_DATATYPE a_Frequency, NOISE_DATATYPE a_Amplitude);
-	
-	void Generate1D(
-		NOISE_DATATYPE * a_Array,                        ///< Array to generate into
-		int a_SizeX,                                     ///< Count of the array
-		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array
-		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
-	) const;
-	
-	
-	void Generate2D(
-		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y]
-		int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
-		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
-		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
-	) const;
-	
-	
-	void Generate3D(
-		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y + a_SizeX * a_SizeY * z]
-		int a_SizeX, int a_SizeY, int a_SizeZ,           ///< Count of the array, in each direction
-		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
-		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
-		NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ,  ///< Noise-space coords of the array in the Z direction
-		NOISE_DATATYPE * a_Workspace = nullptr              ///< Workspace that this function can use and trash
-	) const;
-	
-protected:
-	class cOctave
-	{
-	public:
-		cCubicNoise m_Noise;
-		
-		NOISE_DATATYPE m_Frequency;  // Coord multiplier
-		NOISE_DATATYPE m_Amplitude;  // Value multiplier
-		
-		cOctave(int a_Seed, NOISE_DATATYPE a_Frequency, NOISE_DATATYPE a_Amplitude) :
-			m_Noise(a_Seed),
-			m_Frequency(a_Frequency),
-			m_Amplitude(a_Amplitude)
-		{
-		}
-	} ;
-	
-	typedef std::vector<cOctave> cOctaves;
-	
-	int      m_Seed;
-	cOctaves m_Octaves;
-} ;
+
+typedef cOctavedNoise<cCubicNoise> cPerlinNoise;
+typedef cOctavedNoise<cRidgedNoise<cCubicNoise>> cRidgedMultiNoise;
 
 
 
@@ -376,8 +286,46 @@ NOISE_DATATYPE cNoise::LinearInterpolate(NOISE_DATATYPE a_A, NOISE_DATATYPE a_B,
 ////////////////////////////////////////////////////////////////////////////////
 // Global functions:
 
-extern void Debug2DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, const AString & a_FileNameBase);
-extern void Debug3DNoise(const NOISE_DATATYPE * a_Noise, int a_SizeX, int a_SizeY, int a_SizeZ, const AString & a_FileNameBase);
+/** Exports the noise array into a file.
+a_Coeff specifies the value that each array value is multiplied by before being converted into a byte. */
+extern void Debug2DNoise(const NOISE_DATATYPE * a_Array, int a_SizeX, int a_SizeY, const AString & a_FileNameBase, NOISE_DATATYPE a_Coeff = 32);
+
+/** Exports the noise array into a set of files, ordered by XY and XZ.
+a_Coeff specifies the value that each array value is multiplied by before being converted into a byte. */
+extern void Debug3DNoise(const NOISE_DATATYPE * a_Array, int a_SizeX, int a_SizeY, int a_SizeZ, const AString & a_FileNameBase, NOISE_DATATYPE a_Coeff = 32);
+
+
+
+
+/** Linearly interpolates between two values.
+Assumes that a_Ratio is in range [0, 1]. */
+inline NOISE_DATATYPE Lerp(NOISE_DATATYPE a_Val1, NOISE_DATATYPE a_Val2, NOISE_DATATYPE a_Ratio)
+{
+	return a_Val1 + (a_Val2 - a_Val1) * a_Ratio;
+}
+
+
+
+
+
+/** Linearly interpolates between two values, clamping the ratio to [0, 1] first. */
+inline NOISE_DATATYPE ClampedLerp(NOISE_DATATYPE a_Val1, NOISE_DATATYPE a_Val2, NOISE_DATATYPE a_Ratio)
+{
+	if (a_Ratio < 0)
+	{
+		return a_Val1;
+	}
+	if (a_Ratio > 1)
+	{
+		return a_Val2;
+	}
+	return Lerp(a_Val1, a_Val2, a_Ratio);
+}
+
+
+
+
+
 
 
 
diff --git a/src/Noise/OctavedNoise.h b/src/Noise/OctavedNoise.h
new file mode 100644
index 000000000..855117289
--- /dev/null
+++ b/src/Noise/OctavedNoise.h
@@ -0,0 +1,192 @@
+
+// OctavedNoise.h
+
+// Implements the cOctavedNoise class template representing a noise generator that layers several octaves of another noise
+
+
+
+
+
+#pragma once
+
+
+
+
+
+template <typename N>
+class cOctavedNoise
+{
+public:
+	cOctavedNoise(int a_Seed = 0):
+		m_Seed(a_Seed)
+	{
+	}
+
+
+	/** Sets a new seed for the generators. Relays the seed to all underlying octaves. */
+	void SetSeed(int a_Seed)
+	{
+		m_Seed = a_Seed;
+		for (auto oct: m_Octaves)
+		{
+			oct->SetSeed(a_Seed);
+		}
+	}
+
+
+	/** Adds a new octave to the list of octaves that compose this noise. */
+	void AddOctave(NOISE_DATATYPE a_Frequency, NOISE_DATATYPE a_Amplitude)
+	{
+		m_Octaves.emplace_back(m_Seed, a_Frequency, a_Amplitude);
+	}
+
+
+	/** Fills a 2D array with the values of the noise. */
+	void Generate2D(
+		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y]
+		int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
+		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
+		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
+		NOISE_DATATYPE * a_Workspace = nullptr           ///< Workspace that this function can use and trash.
+	) const
+	{
+		// Check that state is alright:
+		if (m_Octaves.empty())
+		{
+			ASSERT(!"cOctavedNoise: No octaves to generate!");
+			return;
+		}
+
+		// Allocate the workspace on the heap, if it wasn't given:
+		std::unique_ptr<NOISE_DATATYPE[]> workspaceHeap;
+		if (a_Workspace == nullptr)
+		{
+			workspaceHeap.reset(new NOISE_DATATYPE[a_SizeX * a_SizeY]);
+			a_Workspace = workspaceHeap.get();
+		}
+
+		// Generate the first octave directly into array:
+		const cOctave & FirstOctave = m_Octaves.front();
+		int ArrayCount = a_SizeX * a_SizeY;
+		FirstOctave.m_Noise.Generate2D(
+			a_Workspace, a_SizeX, a_SizeY,
+			a_StartX * FirstOctave.m_Frequency, a_EndX * FirstOctave.m_Frequency,
+			a_StartY * FirstOctave.m_Frequency, a_EndY * FirstOctave.m_Frequency
+		);
+		NOISE_DATATYPE Amplitude = FirstOctave.m_Amplitude;
+		for (int i = 0; i < ArrayCount; i++)
+		{
+			a_Array[i] = a_Workspace[i] * Amplitude;
+		}
+
+		// Add each octave:
+		for (auto itr = m_Octaves.cbegin() + 1, end = m_Octaves.cend(); itr != end; ++itr)
+		{
+			// Generate the noise for the octave:
+			itr->m_Noise.Generate2D(
+				a_Workspace, a_SizeX, a_SizeY,
+				a_StartX * itr->m_Frequency, a_EndX * itr->m_Frequency,
+				a_StartY * itr->m_Frequency, a_EndY * itr->m_Frequency
+			);
+			// Add it into the output:
+			NOISE_DATATYPE Amplitude = itr->m_Amplitude;
+			for (int i = 0; i < ArrayCount; i++)
+			{
+				a_Array[i] += a_Workspace[i] * Amplitude;
+			}
+		}  // for itr - m_Octaves[]
+	}
+
+
+	/** Fills a 3D array with the values of the noise. */
+	void Generate3D(
+		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y + a_SizeX * a_SizeY * z]
+		int a_SizeX, int a_SizeY, int a_SizeZ,           ///< Count of the array, in each direction
+		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
+		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
+		NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ,  ///< Noise-space coords of the array in the Z direction
+		NOISE_DATATYPE * a_Workspace = nullptr           ///< Workspace that this function can use and trash, same size as a_Array
+	) const
+	{
+		// Check that state is alright:
+		if (m_Octaves.empty())
+		{
+			ASSERT(!"cOctavedNoise: No octaves to generate!");
+			return;
+		}
+
+		// Allocate the workspace on the heap, if it wasn't given:
+		std::unique_ptr<NOISE_DATATYPE[]> workspaceHeap;
+		if (a_Workspace == nullptr)
+		{
+			workspaceHeap.reset(new NOISE_DATATYPE[a_SizeX * a_SizeY * a_SizeZ]);
+			a_Workspace = workspaceHeap.get();
+		}
+
+		// Generate the first octave directly into array:
+		const cOctave & FirstOctave = m_Octaves.front();
+		int ArrayCount = a_SizeX * a_SizeY * a_SizeZ;
+		FirstOctave.m_Noise.Generate3D(
+			a_Workspace, a_SizeX, a_SizeY, a_SizeZ,
+			a_StartX * FirstOctave.m_Frequency, a_EndX * FirstOctave.m_Frequency,
+			a_StartY * FirstOctave.m_Frequency, a_EndY * FirstOctave.m_Frequency,
+			a_StartZ * FirstOctave.m_Frequency, a_EndZ * FirstOctave.m_Frequency
+		);
+		NOISE_DATATYPE Amplitude = FirstOctave.m_Amplitude;
+		for (int i = 0; i < ArrayCount; i++)
+		{
+			a_Array[i] = a_Workspace[i] * Amplitude;
+		}
+
+		// Add each octave:
+		for (auto itr = m_Octaves.cbegin() + 1, end = m_Octaves.cend(); itr != end; ++itr)
+		{
+			// Generate the noise for the octave:
+			itr->m_Noise.Generate3D(
+				a_Workspace, a_SizeX, a_SizeY, a_SizeZ,
+				a_StartX * itr->m_Frequency, a_EndX * itr->m_Frequency,
+				a_StartY * itr->m_Frequency, a_EndY * itr->m_Frequency,
+				a_StartZ * itr->m_Frequency, a_EndZ * itr->m_Frequency
+			);
+			// Add it into the output:
+			NOISE_DATATYPE Amplitude = itr->m_Amplitude;
+			for (int i = 0; i < ArrayCount; i++)
+			{
+				a_Array[i] += a_Workspace[i] * Amplitude;
+			}
+		}  // for itr - m_Octaves[]
+	}
+
+protected:
+	/** Stores information and state for one octave of the noise. */
+	class cOctave
+	{
+	public:
+		N m_Noise;
+		
+		/** Coord multiplier. */
+		NOISE_DATATYPE m_Frequency;
+
+		/** Value multiplier. */
+		NOISE_DATATYPE m_Amplitude;
+
+		cOctave(int a_Seed, NOISE_DATATYPE a_Frequency, NOISE_DATATYPE a_Amplitude) :
+			m_Noise(a_Seed),
+			m_Frequency(a_Frequency),
+			m_Amplitude(a_Amplitude)
+		{
+		}
+	} ;
+	typedef std::vector<cOctave> cOctaves;
+
+
+	/** The seed used by the underlying generators. */
+	int m_Seed;
+
+	/** The octaves that compose this noise. */
+	cOctaves m_Octaves;
+};
+
+
+
+
diff --git a/src/Noise/RidgedNoise.h b/src/Noise/RidgedNoise.h
new file mode 100644
index 000000000..69b480f60
--- /dev/null
+++ b/src/Noise/RidgedNoise.h
@@ -0,0 +1,91 @@
+
+// RidgedNoise.h
+
+// Implements the cRidgedNoise template class that generates ridged noise based on another noise provider.
+
+
+
+
+
+#pragma once
+
+
+
+
+
+template <typename N>
+class cRidgedNoise
+{
+public:
+	/** Creates a new instance with the seed set to 0. */
+	cRidgedNoise(void):
+		m_Noise(0)
+	{
+	}
+
+
+	/** Creates a new instance with the specified seed. */
+	cRidgedNoise(int a_Seed):
+		m_Noise(a_Seed)
+	{
+	}
+
+
+	/** Sets the seed for the underlying noise. */
+	void SetSeed(int a_Seed)
+	{
+		m_Noise.SetSeed(a_Seed);
+	}
+
+
+	/** Fills a 2D array with the values of the noise. */
+	void Generate2D(
+		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y]
+		int a_SizeX, int a_SizeY,                        ///< Count of the array, in each direction
+		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
+		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY   ///< Noise-space coords of the array in the Y direction
+	) const
+	{
+		int ArrayCount = a_SizeX * a_SizeY;
+		m_Noise.Generate2D(
+			a_Array, a_SizeX, a_SizeY,
+			a_StartX, a_EndX,
+			a_StartY, a_EndY
+		);
+		for (int i = 0; i < ArrayCount; i++)
+		{
+			a_Array[i] = fabs(a_Array[i]);
+		}
+	}
+
+
+	/** Fills a 3D array with the values of the noise. */
+	void Generate3D(
+		NOISE_DATATYPE * a_Array,                        ///< Array to generate into [x + a_SizeX * y + a_SizeX * a_SizeY * z]
+		int a_SizeX, int a_SizeY, int a_SizeZ,           ///< Count of the array, in each direction
+		NOISE_DATATYPE a_StartX, NOISE_DATATYPE a_EndX,  ///< Noise-space coords of the array in the X direction
+		NOISE_DATATYPE a_StartY, NOISE_DATATYPE a_EndY,  ///< Noise-space coords of the array in the Y direction
+		NOISE_DATATYPE a_StartZ, NOISE_DATATYPE a_EndZ   ///< Noise-space coords of the array in the Z direction
+	) const
+	{
+		int ArrayCount = a_SizeX * a_SizeY * a_SizeZ;
+		m_Noise.Generate2D(
+			a_Array, a_SizeX, a_SizeY, a_SizeZ,
+			a_StartX, a_EndX,
+			a_StartY, a_EndY,
+			a_StartZ, a_EndZ
+		);
+		for (int i = 0; i < ArrayCount; i++)
+		{
+			a_Array[i] = fabs(a_Array[i]);
+		}
+	}
+
+protected:
+	N m_Noise;
+} ;
+
+
+
+
+
diff --git a/src/Root.cpp b/src/Root.cpp
index 49d6117eb..55e1c1156 100644
--- a/src/Root.cpp
+++ b/src/Root.cpp
@@ -634,7 +634,7 @@ bool cRoot::FindAndDoWithPlayer(const AString & a_PlayerName, cPlayerListCallbac
 
 
 bool cRoot::DoWithPlayerByUUID(const AString & a_PlayerUUID, cPlayerListCallback & a_Callback)
-{    
+{
 	for (WorldMap::iterator itr = m_WorldsByName.begin(); itr !=  m_WorldsByName.end();itr++)
 	{
 		if (itr->second->DoWithPlayerByUUID(a_PlayerUUID, a_Callback))
diff --git a/src/Root.h b/src/Root.h
index 618f70fb8..ec6b83fcc 100644
--- a/src/Root.h
+++ b/src/Root.h
@@ -125,7 +125,7 @@ public:
 
 	/// Finds a player from a partial or complete player name and calls the callback - case-insensitive
 	bool FindAndDoWithPlayer(const AString & a_PlayerName, cPlayerListCallback & a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<
-    
+
 	/** Finds the player over his uuid and calls the callback */
 	bool DoWithPlayerByUUID(const AString & a_PlayerUUID, cPlayerListCallback & a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<
 
diff --git a/src/VoronoiMap.h b/src/VoronoiMap.h
index dfb11e9ce..56022849e 100644
--- a/src/VoronoiMap.h
+++ b/src/VoronoiMap.h
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "Noise.h"
+#include "Noise/Noise.h"
 
 
 
diff --git a/src/World.cpp b/src/World.cpp
index 68855e617..df1a97460 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -283,6 +283,7 @@ cWorld::cWorld(const AString & a_WorldName, eDimension a_Dimension, const AStrin
 	m_bCommandBlocksEnabled(true),
 	m_bUseChatPrefixes(false),
 	m_TNTShrapnelLevel(slNone),
+	m_MaxViewDistance(12),
 	m_Scoreboard(this),
 	m_MapManager(this),
 	m_GeneratorCallbacks(*this),
@@ -561,6 +562,8 @@ void cWorld::Start(void)
 	m_BroadcastDeathMessages = IniFile.GetValueSetB("Broadcasting", "BroadcastDeathMessages", true);
 	m_BroadcastAchievementMessages = IniFile.GetValueSetB("Broadcasting", "BroadcastAchievementMessages", true);
 
+	SetMaxViewDistance(IniFile.GetValueSetI("SpawnPosition", "MaxViewDistance", 12));
+
 	// Try to find the "SpawnPosition" key and coord values in the world configuration, set the flag if found
 	int KeyNum = IniFile.FindKey("SpawnPosition");
 	m_IsSpawnExplicitlySet =
@@ -2926,25 +2929,19 @@ bool cWorld::SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AStrin
 	AString Line2(a_Line2);
 	AString Line3(a_Line3);
 	AString Line4(a_Line4);
+
 	if (cRoot::Get()->GetPluginManager()->CallHookUpdatingSign(*this, a_BlockX, a_BlockY, a_BlockZ, Line1, Line2, Line3, Line4, a_Player))
 	{
 		return false;
 	}
+
 	if (m_ChunkMap->SetSignLines(a_BlockX, a_BlockY, a_BlockZ, Line1, Line2, Line3, Line4))
 	{
 		cRoot::Get()->GetPluginManager()->CallHookUpdatedSign(*this, a_BlockX, a_BlockY, a_BlockZ, Line1, Line2, Line3, Line4, a_Player);
 		return true;
 	}
-	return false;
-}
-
 
-
-
-
-bool cWorld::UpdateSign(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player)
-{
-	return SetSignLines(a_BlockX, a_BlockY, a_BlockZ, a_Line1, a_Line2, a_Line3, a_Line4, a_Player);
+	return false;
 }
 
 
diff --git a/src/World.h b/src/World.h
index f1bf9371a..fe57b0789 100644
--- a/src/World.h
+++ b/src/World.h
@@ -26,6 +26,7 @@
 #include "MapManager.h"
 #include "Blocks/WorldInterface.h"
 #include "Blocks/BroadcastInterface.h"
+#include "ClientHandle.h"
 
 
 
@@ -325,7 +326,7 @@ public:
 	
 	/** Finds the player over his uuid and calls the callback */
 	bool DoWithPlayerByUUID(const AString & a_PlayerUUID, cPlayerListCallback & a_Callback);  // >> EXPORTED IN MANUALBINDINGS <<
-    
+
 	void SendPlayerList(cPlayer * a_DestPlayer);  // Sends playerlist to the player
 
 	/** Adds the entity into its appropriate chunk; takes ownership of the entity ptr.
@@ -377,11 +378,8 @@ public:
 	/** Marks the chunk as failed-to-load: */
 	void ChunkLoadFailed(int a_ChunkX, int a_ChunkZ);
 	
-	/** Sets the sign text, asking plugins for permission first. a_Player is the player who this change belongs to, may be nullptr. Returns true if sign text changed. Same as UpdateSign() */
+	/** Sets the sign text, asking plugins for permission first. a_Player is the player who this change belongs to, may be nullptr. Returns true if sign text changed. */
 	bool SetSignLines(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player = nullptr);  // Exported in ManualBindings.cpp
-	
-	/** Sets the sign text, asking plugins for permission first. a_Player is the player who this change belongs to, may be nullptr. Returns true if sign text changed. Same as SetSignLines() */
-	bool UpdateSign(int a_X, int a_Y, int a_Z, const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4, cPlayer * a_Player = nullptr);  // Exported in ManualBindings.cpp
 
 	/** Sets the command block command. Returns true if command changed. */
 	bool SetCommandBlockCommand(int a_BlockX, int a_BlockY, int a_BlockZ, const AString & a_Command);  // tolua_export
@@ -649,6 +647,12 @@ public:
 	eShrapnelLevel GetTNTShrapnelLevel(void) const { return m_TNTShrapnelLevel; }
 	void SetTNTShrapnelLevel(eShrapnelLevel a_Flag) { m_TNTShrapnelLevel = a_Flag; }
 
+	int GetMaxViewDistance(void) const { return m_MaxViewDistance; }
+	void SetMaxViewDistance(int a_MaxViewDistance)
+	{
+		m_MaxViewDistance = Clamp(a_MaxViewDistance, cClientHandle::MIN_VIEW_DISTANCE, cClientHandle::MAX_VIEW_DISTANCE);
+	}
+
 	bool ShouldUseChatPrefixes(void) const { return m_bUseChatPrefixes; }
 	void SetShouldUseChatPrefixes(bool a_Flag) { m_bUseChatPrefixes = a_Flag; }
 
@@ -964,6 +968,9 @@ private:
 	*/
 	eShrapnelLevel m_TNTShrapnelLevel;
 
+	/** The maximum view distance that a player can have in this world. */
+	int m_MaxViewDistance;
+
 	/** Name of the nether world */
 	AString m_NetherWorldName;