TerrainGenerator Class Reference

#include <TerrainGenerator.hxx>

Collaboration diagram for TerrainGenerator:

Public Member Functions
	TerrainGenerator ()=default
	~TerrainGenerator ()=default
void	generateTerrain (std::vector< MapNode > &mapNodes, std::vector< MapNode * > &mapNodesInDrawingOrder)
void	generateRiver (std::vector< MapNode > &mapNodes)
void	loadTerrainDataFromJSON ()

Private Attributes
TerrainSettings	m_terrainSettings
std::map< std::string, BiomeData >	m_biomeInformation
	key: biome More...
std::vector< Point >	m_riverSourceNodes

Detailed Description

Definition at line 47 of file TerrainGenerator.hxx.

Constructor & Destructor Documentation

TerrainGenerator()

TerrainGenerator::TerrainGenerator ( )

default

~TerrainGenerator()

TerrainGenerator::~TerrainGenerator ( )

default

Member Function Documentation

generateRiver()

void TerrainGenerator::generateRiver

(

std::vector< MapNode > &

mapNodes

)

Definition at line 179 of file TerrainGenerator.cxx.

{
  std::unordered_set<Point> riverNodes;
  std::vector<Point> neighbors;
  Point curPoint, nextPoint;
  double curHeight, nextHeight, neighborHeight;
  int riverNumber = 0;
 
  for (int i = 0; i < m_riverSourceNodes.size(); i++)
  {
    curPoint = m_riverSourceNodes[i];
    curHeight = mapNodes[curPoint.toIndex()].getCoordinates().rawHeight;
 
    while (true)
    {
      if (riverNodes.find(curPoint) != riverNodes.end())
        riverNodes.insert(curPoint);
 
      // Find the lowest node
      nextHeight = 32;
      neighbors = PointFunctions::getNeighbors(curPoint, false);
      for (int j = 0; j < neighbors.size(); ++j)
      {
        if (riverNodes.find(neighbors[j]) != riverNodes.end())
          continue;
        neighborHeight = mapNodes[neighbors[j].toIndex()].getCoordinates().rawHeight;
        if (neighborHeight < nextHeight)
        {
          nextHeight = neighborHeight;
          nextPoint = neighbors[j];
        }
      }
 
      // Add lowest nodes in the area to riverNodes
      for (int j = 0; j < neighbors.size(); ++j)
      {
        neighborHeight = mapNodes[neighbors[j].toIndex()].getCoordinates().rawHeight;
        if (neighborHeight <= nextHeight + 0.005 && (riverNodes.find(neighbors[j]) == riverNodes.end()))
        {
          riverNodes.insert(neighbors[j]);
        }
      }
 
      // These nodes can reach the sea, so set nodes to river
      if (curHeight < m_terrainSettings.seaLevel)
      {
        for (Point point: riverNodes)
        {
          MapNode *node = &(mapNodes[point.toIndex()]);
          node->setTileID("water", point);
        }
        riverNumber++;
        riverNodes.clear();
        break;
      }
 
      // Terrain slight rise is not able to stop the river
      if (nextHeight > curHeight + 0.03)
      {
        riverNodes.clear();
        break;
      }
 
      curPoint = nextPoint;
      curHeight = nextHeight;
    }
  }
 
  LOG(LOG_INFO) << __func__ << __LINE__ << "Number of rivers: " << riverNumber;
}

Here is the call graph for this function:

Here is the caller graph for this function:

generateTerrain()

void TerrainGenerator::generateTerrain	(	std::vector< MapNode > &	mapNodes,
		std::vector< MapNode * > &	mapNodesInDrawingOrder
	)

Definition at line 21 of file TerrainGenerator.cxx.

{
  loadTerrainDataFromJSON();
 
  if (m_terrainSettings.seed == 0)
  {
    srand(static_cast<unsigned int>(time(0)));
    m_terrainSettings.seed = rand();
  }
 
  noise::module::Perlin terrainHeightPerlin;
  terrainHeightPerlin.SetSeed(m_terrainSettings.seed);
  terrainHeightPerlin.SetFrequency(0.003 / 32);
  terrainHeightPerlin.SetLacunarity(1.5);
  terrainHeightPerlin.SetOctaveCount(16);
  noise::module::ScaleBias terrainHeightPerlinScaled;
  terrainHeightPerlinScaled.SetSourceModule(0, terrainHeightPerlin);
  terrainHeightPerlinScaled.SetScale(0.25);
  terrainHeightPerlinScaled.SetBias(-0.5);
 
  noise::module::RidgedMulti terrainHeightFractal;
  terrainHeightFractal.SetSeed(m_terrainSettings.seed);
  terrainHeightFractal.SetFrequency(0.005 / 32);
  terrainHeightFractal.SetLacunarity(2);
  noise::module::ScaleBias terrainHeightFractalScaled;
  terrainHeightFractalScaled.SetSourceModule(0, terrainHeightFractal);
  //terrainHeightFractalScaled.SetScale(0.5);
  terrainHeightFractalScaled.SetScale(m_terrainSettings.mountainAmplitude * 0.025);
  terrainHeightFractalScaled.SetBias(0.5);
 
  noise::module::Perlin terrainHeightBlendPerlin;
  terrainHeightBlendPerlin.SetSeed(m_terrainSettings.seed + 1);
  terrainHeightBlendPerlin.SetFrequency(0.005 / 32);
  noise::module::ScaleBias terrainHeightBlendScale;
  terrainHeightBlendScale.SetSourceModule(0, terrainHeightBlendPerlin);
  terrainHeightBlendScale.SetScale(2.0);
  terrainHeightBlendScale.SetBias(-0.1 * m_terrainSettings.mountainAmplitude);
  noise::module::Clamp terrainHeightBlendControl;
  terrainHeightBlendControl.SetSourceModule(0, terrainHeightBlendScale);
  terrainHeightBlendControl.SetBounds(0, 1);
 
  noise::module::Blend terrainHeightBlend;
  terrainHeightBlend.SetSourceModule(0, terrainHeightPerlinScaled);
  terrainHeightBlend.SetSourceModule(1, terrainHeightFractalScaled);
  terrainHeightBlend.SetControlModule(terrainHeightBlendControl);
 
  noise::module::ScaleBias terrainHeightScale;
  terrainHeightScale.SetSourceModule(0, terrainHeightBlend);
  terrainHeightScale.SetScale(20.0);
  terrainHeightScale.SetBias(4.0);
 
  noise::module::Clamp terrainHeight;
  terrainHeight.SetSourceModule(0, terrainHeightScale);
  terrainHeight.SetBounds(0, 255);
 
  // Foliage
  noise::module::Perlin foliageDensityPerlin;
  foliageDensityPerlin.SetSeed(m_terrainSettings.seed + 1234);
  foliageDensityPerlin.SetFrequency(0.05 / 32);
 
  // Arbitrary Noise
  noise::module::Perlin highFrequencyNoise;
  highFrequencyNoise.SetSeed(m_terrainSettings.seed + 42);
  highFrequencyNoise.SetFrequency(1);
 
  const int mapSize = m_terrainSettings.mapSize;
  const size_t vectorSize = static_cast<size_t>(mapSize * mapSize);
  mapNodes.reserve(vectorSize);
 
  // River random source
  std:: minstd_rand riverRand;
  riverRand.seed(m_terrainSettings.seed);
 
  // For now, the biome string is read from settings.json for debugging
  std::string currentBiome = Settings::instance().biome;
 
  // nodes need to be created at the correct vector "coordinates", or else the Z-Order will be broken
  for (int x = 0; x < mapSize; x++)
  {
    for (int y = 0; y < mapSize; y++)
    {
      const int z = 0; // it's not possible to calculate the correct z-index, so set it later in a for loop
      double rawHeight = terrainHeight.GetValue(x * 32, y * 32, 0.5);
      int height = static_cast<int>(rawHeight);
 
      if (height < m_terrainSettings.seaLevel)
      {
        height = m_terrainSettings.seaLevel;
        mapNodes.emplace_back(MapNode{Point{x, y, z, height, rawHeight}, m_biomeInformation[currentBiome].water[0]});
      }
      else
      {
        const double foliageDensity = foliageDensityPerlin.GetValue(x * 32, y * 32, height / 32.0);
        bool placed = false;
 
        if (foliageDensity > 0.0 && height > m_terrainSettings.seaLevel)
        {
          int tileIndex = static_cast<int>(std::abs(round(highFrequencyNoise.GetValue(x * 32, y * 32, height / 32.0) * 200.0)));
 
          if (foliageDensity < 0.1)
          {
            if (tileIndex < 20)
            {
              tileIndex = tileIndex % static_cast<int>(m_biomeInformation[currentBiome].treesLight.size());
              mapNodes.emplace_back(MapNode{Point{x, y, z, height, rawHeight}, m_biomeInformation[currentBiome].terrain[0],
                                            m_biomeInformation[currentBiome].treesLight[tileIndex]});
              placed = true;
            }
          }
          else if (foliageDensity < 0.25)
          {
            if (tileIndex < 50)
            {
              tileIndex = tileIndex % static_cast<int>(m_biomeInformation[currentBiome].treesMedium.size());
              mapNodes.emplace_back(MapNode{Point{x, y, z, height, rawHeight}, m_biomeInformation[currentBiome].terrain[0],
                                            m_biomeInformation[currentBiome].treesMedium[tileIndex]});
              placed = true;
            }
          }
          else if (foliageDensity < 1.0 && tileIndex < 95)
          {
            tileIndex = tileIndex % static_cast<int>(m_biomeInformation[currentBiome].treesDense.size());
 
            mapNodes.emplace_back(MapNode{Point{x, y, z, height, rawHeight}, m_biomeInformation[currentBiome].terrain[0],
                                          m_biomeInformation[currentBiome].treesDense[tileIndex]});
            placed = true;
          }
        }
        if (placed == false)
        {
          mapNodes.emplace_back(MapNode{Point{x, y, z, height, rawHeight}, m_biomeInformation[currentBiome].terrain[0]});
        }
 
        if (height > m_terrainSettings.seaLevel)
        {
          const int riverSourcePossibility = riverRand() % m_terrainSettings.maxHeight;
          if ((riverSourcePossibility >= (m_terrainSettings.maxHeight + m_terrainSettings.seaLevel - height)) && (riverRand() % 50 == 0))
          {
            m_riverSourceNodes.emplace_back(Point{x, y, z, height, rawHeight});
          }
        }
      }
    }
  }
 
  int z = 0;
  // set the z-Index for the mapNodes. It is not used, but it's better to have the correct z-index set
  for (int y = mapSize - 1; y >= 0; y--)
  {
    for (int x = 0; x < mapSize; x++)
    {
      z++;
      mapNodes[x * mapSize + y].setZIndex(z);
      mapNodesInDrawingOrder.push_back(&mapNodes[x * mapSize + y]);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

loadTerrainDataFromJSON()

void TerrainGenerator::loadTerrainDataFromJSON

(

)

Definition at line 250 of file TerrainGenerator.cxx.

{
  std::string jsonFileContent = fs::readFileAsString(TERRAINGEN_DATA_FILE_NAME);
  json biomeDataJsonObject = json::parse(jsonFileContent, nullptr, false);
 
  // check if json file can be parsed
  if (biomeDataJsonObject.is_discarded())
    throw ConfigurationError(TRACE_INFO "Error parsing JSON File " + string{TERRAINGEN_DATA_FILE_NAME});
 
  // parse biome objects
  for (const auto &it : biomeDataJsonObject.items())
  {
    m_biomeInformation[it.key()] = it.value();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_biomeInformation

std::map<std::string, BiomeData> TerrainGenerator::m_biomeInformation

private

key: biome

Definition at line 61 of file TerrainGenerator.hxx.

m_riverSourceNodes

std::vector<Point> TerrainGenerator::m_riverSourceNodes

private

Definition at line 62 of file TerrainGenerator.hxx.

m_terrainSettings

TerrainSettings TerrainGenerator::m_terrainSettings

private

Definition at line 59 of file TerrainGenerator.hxx.

---

The documentation for this class was generated from the following files:

• src/engine/map/TerrainGenerator.hxx
• src/engine/map/TerrainGenerator.cxx