From a245fefe21b4624cc44ab52f4a57a6975983e85e Mon Sep 17 00:00:00 2001 From: Niels Breuker Date: Thu, 21 Mar 2024 21:57:46 +0100 Subject: Moved end generator back to 3d perlin noise --- src/Generating/EndGen.cpp | 182 +++++++++++++++++++++++++--------------------- src/Generating/EndGen.h | 39 ++++++---- 2 files changed, 127 insertions(+), 94 deletions(-) diff --git a/src/Generating/EndGen.cpp b/src/Generating/EndGen.cpp index 47ea052c6..a4a55d74f 100644 --- a/src/Generating/EndGen.cpp +++ b/src/Generating/EndGen.cpp @@ -23,7 +23,7 @@ enum DIM_X = 16 / INTERPOL_X + 1, DIM_Y = 256 / INTERPOL_Y + 1, DIM_Z = 16 / INTERPOL_Z + 1, -} ; +}; @@ -34,26 +34,23 @@ enum cEndGen::cEndGen(int a_Seed) : m_Seed(a_Seed), - m_Perlin(a_Seed), - m_VoidOffsetNoise(a_Seed + 1000), - m_AirThresholdMainIsland(0.0f), - m_AirThresholdOtherIslands(0.5f), - m_MainIslandSize(450), - m_BaseHeight(64), - m_TerrainTopMultiplier(10), - m_TerrainBottomMultiplier(40), - m_VoidOffsetNoiseMultiplier(50), - m_FrequencyX(80), - m_FrequencyY(80), - m_FrequencyZ(80) + m_Perlin(m_Seed), + m_MainIslandSize(200), + m_IslandThickness(32), + m_IslandYOffset(30), + m_MainIslandFrequencyX(100), + m_MainIslandFrequencyY(80), + m_MainIslandFrequencyZ(100), + m_MainIslandMinThreshold(0.2), + m_SmallIslandFrequencyX(50), + m_SmallIslandFrequencyY(80), + m_SmallIslandFrequencyZ(50), + m_SmallIslandMinThreshold(-0.5), + m_LastChunkCoords(0x7fffffff, 0x7fffffff) // Use dummy coords that won't ever be used by real chunks { m_Perlin.AddOctave(1, 1); m_Perlin.AddOctave(2, 0.5); m_Perlin.AddOctave(4, 0.25); - - m_VoidOffsetNoise.AddOctave(1, 1); - m_VoidOffsetNoise.AddOctave(2, 0.5); - m_VoidOffsetNoise.AddOctave(4, 0.25); } @@ -62,95 +59,118 @@ cEndGen::cEndGen(int a_Seed) : void cEndGen::InitializeShapeGen(cIniFile & a_IniFile) { - m_AirThresholdMainIsland = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenAirThresholdMainIsland", m_AirThresholdMainIsland)); - m_AirThresholdOtherIslands = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenAirThresholdOtherIslands", m_AirThresholdOtherIslands)); m_MainIslandSize = a_IniFile.GetValueSetI("Generator", "EndGenMainIslandSize", m_MainIslandSize); - m_BaseHeight = a_IniFile.GetValueSetI("Generator", "EndGenBaseHeight", m_BaseHeight); - m_TerrainTopMultiplier = a_IniFile.GetValueSetI("Generator", "EndGenTerrainTopMultiplier", m_TerrainTopMultiplier); - m_TerrainBottomMultiplier = a_IniFile.GetValueSetI("Generator", "EndGenTerrainBottomMultiplier", m_TerrainBottomMultiplier); - m_VoidOffsetNoiseMultiplier = a_IniFile.GetValueSetI("Generator", "EndGenVoidOffsetNoiseMultiplier", m_VoidOffsetNoiseMultiplier); - - m_FrequencyX = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenFrequencyX", m_FrequencyX)); - m_FrequencyY = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenFrequencyY", m_FrequencyY)); - m_FrequencyZ = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenFrequencyZ", m_FrequencyZ)); + m_IslandThickness = a_IniFile.GetValueSetI("Generator", "EndGenIslandFlatness", m_IslandThickness); + m_IslandYOffset = a_IniFile.GetValueSetI("Generator", "EndGenIslandYOffset", m_IslandYOffset); + + m_MainIslandFrequencyX = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenMainFrequencyX", m_MainIslandFrequencyX)); + m_MainIslandFrequencyY = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenMainFrequencyY", m_MainIslandFrequencyY)); + m_MainIslandFrequencyZ = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenMainFrequencyZ", m_MainIslandFrequencyZ)); + m_MainIslandMinThreshold = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenMainMinThreshold", m_MainIslandMinThreshold)); + + m_SmallIslandFrequencyX = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenSmallFrequencyX", m_SmallIslandFrequencyX)); + m_SmallIslandFrequencyY = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenSmallFrequencyY", m_SmallIslandFrequencyY)); + m_SmallIslandFrequencyZ = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenSmallFrequencyZ", m_SmallIslandFrequencyZ)); + m_SmallIslandMinThreshold = static_cast(a_IniFile.GetValueSetF("Generator", "EndGenSmallMinThreshold", m_SmallIslandMinThreshold)); + } -void cEndGen::GenShape(cChunkCoords a_ChunkCoords, cChunkDesc::Shape & a_Shape) +void cEndGen::PrepareState(cChunkCoords a_ChunkCoords) { - for (size_t i = 0; i < ARRAYCOUNT(a_Shape); i++) + if (m_LastChunkCoords == a_ChunkCoords) { - a_Shape[i] = 0; + return; } - NOISE_DATATYPE NoiseData[cChunkDef::Width * cChunkDef::Width]; - NOISE_DATATYPE VoidOffsetData[cChunkDef::Width * cChunkDef::Width]; - NOISE_DATATYPE Workspace[cChunkDef::Width * cChunkDef::Width]; - NOISE_DATATYPE StartX = static_cast(a_ChunkCoords.m_ChunkX * cChunkDef::Width) / m_FrequencyX; - NOISE_DATATYPE EndX = static_cast((a_ChunkCoords.m_ChunkX + 1) * cChunkDef::Width) / m_FrequencyX; - NOISE_DATATYPE StartZ = static_cast(a_ChunkCoords.m_ChunkZ * cChunkDef::Width) / m_FrequencyZ; - NOISE_DATATYPE EndZ = static_cast((a_ChunkCoords.m_ChunkZ + 1) * cChunkDef::Width) / m_FrequencyZ; + m_LastChunkCoords = a_ChunkCoords; - m_Perlin.Generate2D(NoiseData, cChunkDef::Width, cChunkDef::Width, StartX, EndX, StartZ, EndZ, Workspace); - m_VoidOffsetNoise.Generate2D(VoidOffsetData, cChunkDef::Width, cChunkDef::Width, StartX, EndX, StartZ, EndZ, Workspace); + GenerateNoiseArray(); +} - for (int z = 0; z < cChunkDef::Width; z++) + + + + +void cEndGen::GenerateNoiseArray(void) +{ + NOISE_DATATYPE NoiseData[DIM_X * DIM_Y * DIM_Z]; // [x + DIM_X * z + DIM_X * DIM_Z * y] + NOISE_DATATYPE Workspace[DIM_X * DIM_Y * DIM_Z]; // [x + DIM_X * z + DIM_X * DIM_Z * y] + + // Choose the frequency to use depending on the distance from spawn. + double distanceFromSpawn = cChunkDef::RelativeToAbsolute({ cChunkDef::Width / 2, 0, cChunkDef::Width / 2 }, m_LastChunkCoords).Length(); + NOISE_DATATYPE frequencyX = distanceFromSpawn > m_MainIslandSize * 2 ? m_SmallIslandFrequencyX : m_MainIslandFrequencyX; + NOISE_DATATYPE frequencyY = distanceFromSpawn > m_MainIslandSize * 2 ? m_SmallIslandFrequencyY : m_MainIslandFrequencyY; + NOISE_DATATYPE frequencyZ = distanceFromSpawn > m_MainIslandSize * 2 ? m_SmallIslandFrequencyZ : m_MainIslandFrequencyZ; + + // Generate the downscaled noise: + NOISE_DATATYPE StartX = static_cast(m_LastChunkCoords.m_ChunkX * cChunkDef::Width) / frequencyX; + NOISE_DATATYPE EndX = static_cast((m_LastChunkCoords.m_ChunkX + 1) * cChunkDef::Width) / frequencyX; + NOISE_DATATYPE StartZ = static_cast(m_LastChunkCoords.m_ChunkZ * cChunkDef::Width) / frequencyZ; + NOISE_DATATYPE EndZ = static_cast((m_LastChunkCoords.m_ChunkZ + 1) * cChunkDef::Width) / frequencyZ; + NOISE_DATATYPE StartY = 0; + NOISE_DATATYPE EndY = static_cast(257) / frequencyY; + m_Perlin.Generate3D(NoiseData, DIM_X, DIM_Z, DIM_Y, StartX, EndX, StartZ, EndZ, StartY, EndY, Workspace); + + // Add distance: + for (int y = 0; y < DIM_Y; y++) { - for (int x = 0; x < cChunkDef::Width; x++) + NOISE_DATATYPE ValY = static_cast(2 * INTERPOL_Y * y - m_IslandThickness) / m_IslandThickness; + ValY = std::pow(ValY, 6); + for (int z = 0; z < DIM_Z; z++) { - NOISE_DATATYPE noise = NoiseData[z * cChunkDef::Width + x]; + for (int x = 0; x < DIM_X; x++) + { + NoiseData[x + DIM_X * z + DIM_X * DIM_Z * y] += ValY; + } // for x + } // for z + } // for y - // The distance from spawn is used to create the void between the main island and the other islands. - double distanceFromSpawn = cChunkDef::RelativeToAbsolute({ x, 0, z }, a_ChunkCoords).Length(); + // Upscale into real chunk size: + LinearUpscale3DArray(NoiseData, DIM_X, DIM_Z, DIM_Y, m_NoiseArray, INTERPOL_X, INTERPOL_Z, INTERPOL_Y); +} - // The main island can get a different airthreshold. This way the other island can be more sparse while the main island - // is one big island. - if (distanceFromSpawn > m_MainIslandSize) - { - if (noise <= m_AirThresholdOtherIslands) - { - continue; - } - noise -= m_AirThresholdOtherIslands; - } - else - { - if (noise <= m_AirThresholdMainIsland) - { - continue; - } - noise -= m_AirThresholdMainIsland; - } - NOISE_DATATYPE voidOffset = VoidOffsetData[z * cChunkDef::Width + x]; - double maxHeightLimit; - if (distanceFromSpawn > m_MainIslandSize * 3) + + +void cEndGen::GenShape(cChunkCoords a_ChunkCoords, cChunkDesc::Shape & a_Shape) +{ + PrepareState(a_ChunkCoords); + + int MaxY = std::min(static_cast(1.75 * m_IslandThickness + m_IslandYOffset), cChunkDef::Height - 1); + + // Choose which threshold to use depending on the distance from spawn. + double distanceFromSpawn = cChunkDef::RelativeToAbsolute({ cChunkDef::Width / 2, 0, cChunkDef::Width / 2 }, a_ChunkCoords).Length(); + double minThreshold = distanceFromSpawn > m_MainIslandSize * 2 ? m_SmallIslandMinThreshold : m_MainIslandMinThreshold; + for (int z = 0; z < cChunkDef::Width; z++) + { + for (int x = 0; x < cChunkDef::Width; x++) + { + // Calculate the required treshold based on the distance from spawn. + // This way a void can be generated between the main island and the other islands. + double distanceFromSpawn = cChunkDef::RelativeToAbsolute({ x, 0, z }, a_ChunkCoords).Length(); + double pow = std::pow((distanceFromSpawn - m_MainIslandSize) / m_MainIslandSize / 2, 3); + double mult = 3 * ((distanceFromSpawn - m_MainIslandSize) / m_MainIslandSize); + double threshold = std::min(pow - mult, minThreshold); + + for (int y = 0; y < m_IslandYOffset; y++) { - // The distance from spawn is so big we don't need to calculate the max height anymore. - // In fact, if we don't cut it off somewhere there is a chance the maxheight gets too big which - // can cause corrupted looking terrain. - maxHeightLimit = static_cast(cChunkDef::Height); + a_Shape[y + x * 256 + z * 256 * 16] = 0; } - else + for (int y = m_IslandYOffset; y < MaxY; y++) { - // Create a void between the main island and the other island using the formula 'x^3 - 3 * x' where x is distance from spawn. - double pow = std::pow((distanceFromSpawn - m_MainIslandSize) / m_MainIslandSize, 3); - double mult = 3 * ((distanceFromSpawn - m_MainIslandSize) / m_MainIslandSize); - maxHeightLimit = Clamp((pow - mult) * 100 + static_cast(voidOffset) * m_VoidOffsetNoiseMultiplier, 0.0, static_cast(cChunkDef::Height)); + a_Shape[y + x * 256 + z * 256 * 16] = (m_NoiseArray[(y - m_IslandYOffset) * 17 * 17 + z * 17 + x] <= threshold) ? 1 : 0; } - int maxHeight = static_cast(Clamp(m_BaseHeight + static_cast(noise) * m_TerrainTopMultiplier, 0.0, maxHeightLimit)); - int minHeight = static_cast(Clamp(m_BaseHeight - static_cast(noise) * m_TerrainBottomMultiplier, 0.0, static_cast(cChunkDef::Height))); - - for (int y = minHeight; y < maxHeight; y++) + for (int y = MaxY; y < cChunkDef::Height; y++) { - a_Shape[y + x * 256 + z * 256 * 16] = 1; + a_Shape[y + x * 256 + z * 256 * 16] = 0; } - } - } + } // for x + } // for z } diff --git a/src/Generating/EndGen.h b/src/Generating/EndGen.h index bd1debdeb..4763352b2 100644 --- a/src/Generating/EndGen.h +++ b/src/Generating/EndGen.h @@ -30,28 +30,41 @@ protected: /** The Perlin noise used for generating */ cPerlinNoise m_Perlin; - cPerlinNoise m_VoidOffsetNoise; - NOISE_DATATYPE m_AirThresholdMainIsland; - NOISE_DATATYPE m_AirThresholdOtherIslands; + // XYZ size of the "island", in blocks: int m_MainIslandSize; - int m_BaseHeight; - int m_TerrainTopMultiplier; - int m_TerrainBottomMultiplier; - int m_VoidOffsetNoiseMultiplier; + int m_IslandThickness; + int m_IslandYOffset; // XYZ Frequencies of the noise functions: - NOISE_DATATYPE m_FrequencyX; - NOISE_DATATYPE m_FrequencyY; - NOISE_DATATYPE m_FrequencyZ; + NOISE_DATATYPE m_MainIslandFrequencyX; + NOISE_DATATYPE m_MainIslandFrequencyY; + NOISE_DATATYPE m_MainIslandFrequencyZ; + NOISE_DATATYPE m_MainIslandMinThreshold; + + // XYZ Frequencies of the noise functions on the smaller islands: + NOISE_DATATYPE m_SmallIslandFrequencyX; + NOISE_DATATYPE m_SmallIslandFrequencyY; + NOISE_DATATYPE m_SmallIslandFrequencyZ; + NOISE_DATATYPE m_SmallIslandMinThreshold; + + + // Noise array for the last chunk (in the noise range) + cChunkCoords m_LastChunkCoords; + NOISE_DATATYPE m_NoiseArray[17 * 17 * 257]; // x + 17 * z + 17 * 17 * y + + + /** Unless the LastChunk coords are equal to coords given, prepares the internal state (noise array) */ + void PrepareState(cChunkCoords a_ChunkCoords); + + /** Generates the m_NoiseArray array for the current chunk */ + void GenerateNoiseArray(void); // cTerrainShapeGen overrides: virtual void GenShape(cChunkCoords a_ChunkCoords, cChunkDesc::Shape & a_Shape) override; + virtual void InitializeShapeGen(cIniFile & a_IniFile) override; // cTerrainCompositionGen overrides: virtual void ComposeTerrain(cChunkDesc & a_ChunkDesc, const cChunkDesc::Shape & a_Shape) override; - - // cTerrainShapeGen overrides: - virtual void InitializeShapeGen(cIniFile & a_IniFile) override; } ; -- cgit v1.2.3