luanti-org/luanti
1
0
Fork 0
mirror of https://github.com/luanti-org/luanti.git synced 2025-10-17 10:25:21 +02:00
Code Activity

Rename perlin noise to value noise (#15858)

Browse Source
This commit is contained in:
Erich Schubert
2025-04-10 14:39:40 +02:00
committed by GitHub
parent 372e37faf2
commit 78293404c7
27 changed files with 339 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/mapgen/cavegen.cpp
View File

@@ -61,8 +61,8 @@ void CavesNoiseIntersection::generateCaves(MMVManip *vm,
assert(vm);
assert(biomemap);
noise_cave1->perlinMap3D(nmin.X, nmin.Y - 1, nmin.Z);
noise_cave2->perlinMap3D(nmin.X, nmin.Y - 1, nmin.Z);
noise_cave1->noiseMap3D(nmin.X, nmin.Y - 1, nmin.Z);
noise_cave2->noiseMap3D(nmin.X, nmin.Y - 1, nmin.Z);
const v3s32 &em = vm->m_area.getExtent();
u32 index2d = 0; // Biomemap index
@@ -218,7 +218,7 @@ bool CavernsNoise::generateCaverns(MMVManip *vm, v3s16 nmin, v3s16 nmax)
assert(vm);
// Calculate noise
noise_cavern->perlinMap3D(nmin.X, nmin.Y - 1, nmin.Z);
noise_cavern->noiseMap3D(nmin.X, nmin.Y - 1, nmin.Z);
// Cache cavern_amp values
float *cavern_amp = new float[m_csize.Y + 1];
@@ -532,7 +532,7 @@ void CavesRandomWalk::carveRoute(v3f vec, float f, bool randomize_xz)
// If cave liquid not defined by biome, fallback to old hardcoded behavior.
// TODO 'np_caveliquids' is deprecated and should eventually be removed.
// Cave liquids are now defined and located using biome definitions.
float nval = NoisePerlin3D(np_caveliquids, startp.X,
float nval = NoiseFractal3D(np_caveliquids, startp.X,
startp.Y, startp.Z, seed);
liquidnode = (nval < 0.40f && node_max.Y < water_level - 256) ?
lavanode : waternode;

2
src/mapgen/dungeongen.cpp
View File

@@ -114,7 +114,7 @@ void DungeonGen::generate(MMVManip *vm, u32 bseed, v3s16 nmin, v3s16 nmax)
u32 i = vm->m_area.index(nmin.X, y, z);
for (s16 x = nmin.X; x <= nmax.X; x++) {
if (vm->m_data[i].getContent() == dp.c_wall) {
if (NoisePerlin3D(&dp.np_alt_wall, x, y, z, blockseed) > 0.0f)
if (NoiseFractal3D(&dp.np_alt_wall, x, y, z, blockseed) > 0.0f)
vm->m_data[i].setContent(dp.c_alt_wall);
}
i++;

4
src/mapgen/mapgen.cpp
View File

@@ -632,7 +632,7 @@ void MapgenBasic::generateBiomes()
const v3s32 &em = vm->m_area.getExtent();
u32 index = 0;
noise_filler_depth->perlinMap2D(node_min.X, node_min.Z);
noise_filler_depth->noiseMap2D(node_min.X, node_min.Z);
for (s16 z = node_min.Z; z <= node_max.Z; z++)
for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
@@ -897,7 +897,7 @@ void MapgenBasic::generateDungeons(s16 max_stone_y)
return;
u16 num_dungeons = std::fmax(std::floor(
NoisePerlin3D(&np_dungeons, node_min.X, node_min.Y, node_min.Z, seed)), 0.0f);
NoiseFractal3D(&np_dungeons, node_min.X, node_min.Y, node_min.Z, seed)), 0.0f);
if (num_dungeons == 0)
return;

50
src/mapgen/mapgen_carpathian.cpp
View File

@@ -329,34 +329,34 @@ int MapgenCarpathian::getSpawnLevelAtPoint(v2s16 p)
{
// If rivers are enabled, first check if in a river channel
if (spflags & MGCARPATHIAN_RIVERS) {
float river = std::fabs(NoisePerlin2D(&noise_rivers->np, p.X, p.Y, seed)) -
float river = std::fabs(NoiseFractal2D(&noise_rivers->np, p.X, p.Y, seed)) -
river_width;
if (river < 0.0f)
return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
}
float height1 = NoisePerlin2D(&noise_height1->np, p.X, p.Y, seed);
float height2 = NoisePerlin2D(&noise_height2->np, p.X, p.Y, seed);
float height3 = NoisePerlin2D(&noise_height3->np, p.X, p.Y, seed);
float height4 = NoisePerlin2D(&noise_height4->np, p.X, p.Y, seed);
float height1 = NoiseFractal2D(&noise_height1->np, p.X, p.Y, seed);
float height2 = NoiseFractal2D(&noise_height2->np, p.X, p.Y, seed);
float height3 = NoiseFractal2D(&noise_height3->np, p.X, p.Y, seed);
float height4 = NoiseFractal2D(&noise_height4->np, p.X, p.Y, seed);
float hterabs = std::fabs(NoisePerlin2D(&noise_hills_terrain->np, p.X, p.Y, seed));
float n_hills = NoisePerlin2D(&noise_hills->np, p.X, p.Y, seed);
float hterabs = std::fabs(NoiseFractal2D(&noise_hills_terrain->np, p.X, p.Y, seed));
float n_hills = NoiseFractal2D(&noise_hills->np, p.X, p.Y, seed);
float hill_mnt = hterabs * hterabs * hterabs * n_hills * n_hills;
float rterabs = std::fabs(NoisePerlin2D(&noise_ridge_terrain->np, p.X, p.Y, seed));
float n_ridge_mnt = NoisePerlin2D(&noise_ridge_mnt->np, p.X, p.Y, seed);
float rterabs = std::fabs(NoiseFractal2D(&noise_ridge_terrain->np, p.X, p.Y, seed));
float n_ridge_mnt = NoiseFractal2D(&noise_ridge_mnt->np, p.X, p.Y, seed);
float ridge_mnt = rterabs * rterabs * rterabs * (1.0f - std::fabs(n_ridge_mnt));
float sterabs = std::fabs(NoisePerlin2D(&noise_step_terrain->np, p.X, p.Y, seed));
float n_step_mnt = NoisePerlin2D(&noise_step_mnt->np, p.X, p.Y, seed);
float sterabs = std::fabs(NoiseFractal2D(&noise_step_terrain->np, p.X, p.Y, seed));
float n_step_mnt = NoiseFractal2D(&noise_step_mnt->np, p.X, p.Y, seed);
float step_mnt = sterabs * sterabs * sterabs * getSteps(n_step_mnt);
float valley = 1.0f;
float river = 0.0f;
if ((spflags & MGCARPATHIAN_RIVERS) && node_max.Y >= water_level - 16) {
river = std::fabs(NoisePerlin2D(&noise_rivers->np, p.X, p.Y, seed)) - river_width;
river = std::fabs(NoiseFractal2D(&noise_rivers->np, p.X, p.Y, seed)) - river_width;
if (river <= valley_width) {
// Within river valley
if (river < 0.0f) {
@@ -376,7 +376,7 @@ int MapgenCarpathian::getSpawnLevelAtPoint(v2s16 p)
u8 cons_non_solid = 0; // consecutive non-solid nodes
for (s16 y = water_level; y <= water_level + 32; y++) {
float mnt_var = NoisePerlin3D(&noise_mnt_var->np, p.X, y, p.Y, seed);
float mnt_var = NoiseFractal3D(&noise_mnt_var->np, p.X, y, p.Y, seed);
float hill1 = getLerp(height1, height2, mnt_var);
float hill2 = getLerp(height3, height4, mnt_var);
float hill3 = getLerp(height3, height2, mnt_var);
@@ -429,20 +429,20 @@ int MapgenCarpathian::generateTerrain()
MapNode mn_water(c_water_source);
// Calculate noise for terrain generation
noise_height1->perlinMap2D(node_min.X, node_min.Z);
noise_height2->perlinMap2D(node_min.X, node_min.Z);
noise_height3->perlinMap2D(node_min.X, node_min.Z);
noise_height4->perlinMap2D(node_min.X, node_min.Z);
noise_hills_terrain->perlinMap2D(node_min.X, node_min.Z);
noise_ridge_terrain->perlinMap2D(node_min.X, node_min.Z);
noise_step_terrain->perlinMap2D(node_min.X, node_min.Z);
noise_hills->perlinMap2D(node_min.X, node_min.Z);
noise_ridge_mnt->perlinMap2D(node_min.X, node_min.Z);
noise_step_mnt->perlinMap2D(node_min.X, node_min.Z);
noise_mnt_var->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
noise_height1->noiseMap2D(node_min.X, node_min.Z);
noise_height2->noiseMap2D(node_min.X, node_min.Z);
noise_height3->noiseMap2D(node_min.X, node_min.Z);
noise_height4->noiseMap2D(node_min.X, node_min.Z);
noise_hills_terrain->noiseMap2D(node_min.X, node_min.Z);
noise_ridge_terrain->noiseMap2D(node_min.X, node_min.Z);
noise_step_terrain->noiseMap2D(node_min.X, node_min.Z);
noise_hills->noiseMap2D(node_min.X, node_min.Z);
noise_ridge_mnt->noiseMap2D(node_min.X, node_min.Z);
noise_step_mnt->noiseMap2D(node_min.X, node_min.Z);
noise_mnt_var->noiseMap3D(node_min.X, node_min.Y - 1, node_min.Z);
if (spflags & MGCARPATHIAN_RIVERS)
noise_rivers->perlinMap2D(node_min.X, node_min.Z);
noise_rivers->noiseMap2D(node_min.X, node_min.Z);
//// Place nodes
const v3s32 &em = vm->m_area.getExtent();

4
src/mapgen/mapgen_flat.cpp
View File

@@ -164,7 +164,7 @@ int MapgenFlat::getSpawnLevelAtPoint(v2s16 p)
s16 stone_level = ground_level;
float n_terrain =
((spflags & MGFLAT_LAKES) || (spflags & MGFLAT_HILLS)) ?
NoisePerlin2D(&noise_terrain->np, p.X, p.Y, seed) :
NoiseFractal2D(&noise_terrain->np, p.X, p.Y, seed) :
0.0f;
if ((spflags & MGFLAT_LAKES) && n_terrain < lake_threshold) {
@@ -284,7 +284,7 @@ s16 MapgenFlat::generateTerrain()
bool use_noise = (spflags & MGFLAT_LAKES) || (spflags & MGFLAT_HILLS);
if (use_noise)
noise_terrain->perlinMap2D(node_min.X, node_min.Z);
noise_terrain->noiseMap2D(node_min.X, node_min.Z);
for (s16 z = node_min.Z; z <= node_max.Z; z++)
for (s16 x = node_min.X; x <= node_max.X; x++, ni2d++) {

4
src/mapgen/mapgen_fractal.cpp
View File

@@ -177,7 +177,7 @@ int MapgenFractal::getSpawnLevelAtPoint(v2s16 p)
// If terrain present, don't start search below terrain or water level
if (noise_seabed) {
s16 seabed_level = NoisePerlin2D(&noise_seabed->np, p.X, p.Y, seed);
s16 seabed_level = NoiseFractal2D(&noise_seabed->np, p.X, p.Y, seed);
search_start = MYMAX(search_start, MYMAX(seabed_level, water_level));
}
@@ -409,7 +409,7 @@ s16 MapgenFractal::generateTerrain()
u32 index2d = 0;
if (noise_seabed)
noise_seabed->perlinMap2D(node_min.X, node_min.Z);
noise_seabed->noiseMap2D(node_min.X, node_min.Z);
for (s16 z = node_min.Z; z <= node_max.Z; z++) {
for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {

12
src/mapgen/mapgen_v5.cpp
View File

@@ -150,12 +150,12 @@ void MapgenV5Params::setDefaultSettings(Settings *settings)
int MapgenV5::getSpawnLevelAtPoint(v2s16 p)
{
float f = 0.55 + NoisePerlin2D(&noise_factor->np, p.X, p.Y, seed);
float f = 0.55 + NoiseFractal2D(&noise_factor->np, p.X, p.Y, seed);
if (f < 0.01)
f = 0.01;
else if (f >= 1.0)
f *= 1.6;
float h = NoisePerlin2D(&noise_height->np, p.X, p.Y, seed);
float h = NoiseFractal2D(&noise_height->np, p.X, p.Y, seed);
// noise_height 'offset' is the average level of terrain. At least 50% of
// terrain will be below this.
@@ -166,7 +166,7 @@ int MapgenV5::getSpawnLevelAtPoint(v2s16 p)
// Starting spawn search at max_spawn_y + 128 ensures 128 nodes of open
// space above spawn position. Avoids spawning in possibly sealed voids.
for (s16 y = max_spawn_y + 128; y >= water_level; y--) {
float n_ground = NoisePerlin3D(&noise_ground->np, p.X, y, p.Y, seed);
float n_ground = NoiseFractal3D(&noise_ground->np, p.X, y, p.Y, seed);
if (n_ground * f > y - h) { // If solid
if (y < water_level || y > max_spawn_y)
@@ -272,9 +272,9 @@ int MapgenV5::generateBaseTerrain()
u32 index2d = 0;
int stone_surface_max_y = -MAX_MAP_GENERATION_LIMIT;
noise_factor->perlinMap2D(node_min.X, node_min.Z);
noise_height->perlinMap2D(node_min.X, node_min.Z);
noise_ground->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
noise_factor->noiseMap2D(node_min.X, node_min.Z);
noise_height->noiseMap2D(node_min.X, node_min.Z);
noise_ground->noiseMap3D(node_min.X, node_min.Y - 1, node_min.Z);
for (s16 z=node_min.Z; z<=node_max.Z; z++) {
for (s16 y=node_min.Y - 1; y<=node_max.Y + 1; y++) {

44
src/mapgen/mapgen_v6.cpp
View File

@@ -289,13 +289,13 @@ float MapgenV6::baseTerrainLevelFromNoise(v2s16 p)
if (spflags & MGV6_FLAT)
return water_level;
float terrain_base = NoisePerlin2D_PO(&noise_terrain_base->np,
float terrain_base = NoiseFractal2D_PO(&noise_terrain_base->np,
p.X, 0.5, p.Y, 0.5, seed);
float terrain_higher = NoisePerlin2D_PO(&noise_terrain_higher->np,
float terrain_higher = NoiseFractal2D_PO(&noise_terrain_higher->np,
p.X, 0.5, p.Y, 0.5, seed);
float steepness = NoisePerlin2D_PO(&noise_steepness->np,
float steepness = NoiseFractal2D_PO(&noise_steepness->np,
p.X, 0.5, p.Y, 0.5, seed);
float height_select = NoisePerlin2D_PO(&noise_height_select->np,
float height_select = NoiseFractal2D_PO(&noise_height_select->np,
p.X, 0.5, p.Y, 0.5, seed);
return baseTerrainLevel(terrain_base, terrain_higher,
@@ -355,7 +355,7 @@ BiomeV6Type MapgenV6::getBiome(v2s16 p)
float MapgenV6::getHumidity(v2s16 p)
{
/*double noise = noise2d_perlin(
/*double noise = noise2d_fractal(
0.5+(float)p.X/500, 0.5+(float)p.Y/500,
seed+72384, 4, 0.66);
noise = (noise + 1.0)/2.0;*/
@@ -374,11 +374,11 @@ float MapgenV6::getHumidity(v2s16 p)
float MapgenV6::getTreeAmount(v2s16 p)
{
/*double noise = noise2d_perlin(
/*double noise = noise2d_fractal(
0.5+(float)p.X/125, 0.5+(float)p.Y/125,
seed+2, 4, 0.66);*/
float noise = NoisePerlin2D(np_trees, p.X, p.Y, seed);
float noise = NoiseFractal2D(np_trees, p.X, p.Y, seed);
float zeroval = -0.39;
if (noise < zeroval)
return 0;
@@ -389,11 +389,11 @@ float MapgenV6::getTreeAmount(v2s16 p)
bool MapgenV6::getHaveAppleTree(v2s16 p)
{
/*is_apple_tree = noise2d_perlin(
/*is_apple_tree = noise2d_fractal(
0.5+(float)p.X/100, 0.5+(float)p.Z/100,
data->seed+342902, 3, 0.45) > 0.2;*/
float noise = NoisePerlin2D(np_apple_trees, p.X, p.Y, seed);
float noise = NoiseFractal2D(np_apple_trees, p.X, p.Y, seed);
return noise > 0.2;
}
@@ -404,7 +404,7 @@ float MapgenV6::getMudAmount(int index)
if (spflags & MGV6_FLAT)
return MGV6_AVERAGE_MUD_AMOUNT;
/*return ((float)AVERAGE_MUD_AMOUNT + 2.0 * noise2d_perlin(
/*return ((float)AVERAGE_MUD_AMOUNT + 2.0 * noise2d_fractal(
0.5+(float)p.X/200, 0.5+(float)p.Y/200,
seed+91013, 3, 0.55));*/
@@ -415,7 +415,7 @@ float MapgenV6::getMudAmount(int index)
bool MapgenV6::getHaveBeach(int index)
{
// Determine whether to have sand here
/*double sandnoise = noise2d_perlin(
/*double sandnoise = noise2d_fractal(
0.2+(float)p2d.X/250, 0.7+(float)p2d.Y/250,
seed+59420, 3, 0.50);*/
@@ -427,7 +427,7 @@ bool MapgenV6::getHaveBeach(int index)
BiomeV6Type MapgenV6::getBiome(int index, v2s16 p)
{
// Just do something very simple as for now
/*double d = noise2d_perlin(
/*double d = noise2d_fractal(
0.6+(float)p2d.X/250, 0.2+(float)p2d.Y/250,
seed+9130, 3, 0.50);*/
@@ -547,7 +547,7 @@ void MapgenV6::makeChunk(BlockMakeData *data)
if ((flags & MG_DUNGEONS) && stone_surface_max_y >= node_min.Y &&
full_node_min.Y >= dungeon_ymin && full_node_max.Y <= dungeon_ymax) {
u16 num_dungeons = std::fmax(std::floor(
NoisePerlin3D(&np_dungeons, node_min.X, node_min.Y, node_min.Z, seed)), 0.0f);
NoiseFractal3D(&np_dungeons, node_min.X, node_min.Y, node_min.Z, seed)), 0.0f);
if (num_dungeons >= 1) {
PseudoRandom ps(blockseed + 4713);
@@ -633,17 +633,17 @@ void MapgenV6::calculateNoise()
int fz = full_node_min.Z;
if (!(spflags & MGV6_FLAT)) {
noise_terrain_base->perlinMap2D_PO(x, 0.5, z, 0.5);
noise_terrain_higher->perlinMap2D_PO(x, 0.5, z, 0.5);
noise_steepness->perlinMap2D_PO(x, 0.5, z, 0.5);
noise_height_select->perlinMap2D_PO(x, 0.5, z, 0.5);
noise_mud->perlinMap2D_PO(x, 0.5, z, 0.5);
noise_terrain_base->noiseMap2D_PO(x, 0.5, z, 0.5);
noise_terrain_higher->noiseMap2D_PO(x, 0.5, z, 0.5);
noise_steepness->noiseMap2D_PO(x, 0.5, z, 0.5);
noise_height_select->noiseMap2D_PO(x, 0.5, z, 0.5);
noise_mud->noiseMap2D_PO(x, 0.5, z, 0.5);
}
noise_beach->perlinMap2D_PO(x, 0.2, z, 0.7);
noise_beach->noiseMap2D_PO(x, 0.2, z, 0.7);
noise_biome->perlinMap2D_PO(fx, 0.6, fz, 0.2);
noise_humidity->perlinMap2D_PO(fx, 0.0, fz, 0.0);
noise_biome->noiseMap2D_PO(fx, 0.6, fz, 0.2);
noise_humidity->noiseMap2D_PO(fx, 0.0, fz, 0.0);
// Humidity map does not need range limiting 0 to 1,
// only humidity at point does
}
@@ -1075,7 +1075,7 @@ void MapgenV6::growGrass() // Add surface nodes
void MapgenV6::generateCaves(int max_stone_y)
{
float cave_amount = NoisePerlin2D(np_cave, node_min.X, node_min.Y, seed);
float cave_amount = NoiseFractal2D(np_cave, node_min.X, node_min.Y, seed);
int volume_nodes = (node_max.X - node_min.X + 1) *
(node_max.Y - node_min.Y + 1) * MAP_BLOCKSIZE;
cave_amount = MYMAX(0.0, cave_amount);

32
src/mapgen/mapgen_v7.cpp
View File

@@ -251,7 +251,7 @@ int MapgenV7::getSpawnLevelAtPoint(v2s16 p)
// If rivers are enabled, first check if in a river
if (spflags & MGV7_RIDGES) {
float width = 0.2f;
float uwatern = NoisePerlin2D(&noise_ridge_uwater->np, p.X, p.Y, seed) *
float uwatern = NoiseFractal2D(&noise_ridge_uwater->np, p.X, p.Y, seed) *
2.0f;
if (std::fabs(uwatern) <= width)
return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
@@ -390,16 +390,16 @@ void MapgenV7::makeChunk(BlockMakeData *data)
float MapgenV7::baseTerrainLevelAtPoint(s16 x, s16 z)
{
float hselect = NoisePerlin2D(&noise_height_select->np, x, z, seed);
float hselect = NoiseFractal2D(&noise_height_select->np, x, z, seed);
hselect = rangelim(hselect, 0.0f, 1.0f);
float persist = NoisePerlin2D(&noise_terrain_persist->np, x, z, seed);
float persist = NoiseFractal2D(&noise_terrain_persist->np, x, z, seed);
noise_terrain_base->np.persist = persist;
float height_base = NoisePerlin2D(&noise_terrain_base->np, x, z, seed);
float height_base = NoiseFractal2D(&noise_terrain_base->np, x, z, seed);
noise_terrain_alt->np.persist = persist;
float height_alt = NoisePerlin2D(&noise_terrain_alt->np, x, z, seed);
float height_alt = NoiseFractal2D(&noise_terrain_alt->np, x, z, seed);
if (height_alt > height_base)
return height_alt;
@@ -424,9 +424,9 @@ float MapgenV7::baseTerrainLevelFromMap(int index)
bool MapgenV7::getMountainTerrainAtPoint(s16 x, s16 y, s16 z)
{
float mnt_h_n =
std::fmax(NoisePerlin2D(&noise_mount_height->np, x, z, seed), 1.0f);
std::fmax(NoiseFractal2D(&noise_mount_height->np, x, z, seed), 1.0f);
float density_gradient = -((float)(y - mount_zero_level) / mnt_h_n);
float mnt_n = NoisePerlin3D(&noise_mountain->np, x, y, z, seed);
float mnt_n = NoiseFractal3D(&noise_mountain->np, x, y, z, seed);
return mnt_n + density_gradient >= 0.0f;
}
@@ -472,16 +472,16 @@ int MapgenV7::generateTerrain()
MapNode n_water(c_water_source);
//// Calculate noise for terrain generation
noise_terrain_persist->perlinMap2D(node_min.X, node_min.Z);
noise_terrain_persist->noiseMap2D(node_min.X, node_min.Z);
float *persistmap = noise_terrain_persist->result;
noise_terrain_base->perlinMap2D(node_min.X, node_min.Z, persistmap);
noise_terrain_alt->perlinMap2D(node_min.X, node_min.Z, persistmap);
noise_height_select->perlinMap2D(node_min.X, node_min.Z);
noise_terrain_base->noiseMap2D(node_min.X, node_min.Z, persistmap);
noise_terrain_alt->noiseMap2D(node_min.X, node_min.Z, persistmap);
noise_height_select->noiseMap2D(node_min.X, node_min.Z);
if (spflags & MGV7_MOUNTAINS) {
noise_mount_height->perlinMap2D(node_min.X, node_min.Z);
noise_mountain->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
noise_mount_height->noiseMap2D(node_min.X, node_min.Z);
noise_mountain->noiseMap3D(node_min.X, node_min.Y - 1, node_min.Z);
}
//// Floatlands
@@ -497,7 +497,7 @@ int MapgenV7::generateTerrain()
node_max.Y >= floatland_ymin && node_min.Y <= floatland_ymax) {
gen_floatlands = true;
// Calculate noise for floatland generation
noise_floatland->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
noise_floatland->noiseMap3D(node_min.X, node_min.Y - 1, node_min.Z);
// Cache floatland noise offset values, for floatland tapering
for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++, cache_index++) {
@@ -518,8 +518,8 @@ int MapgenV7::generateTerrain()
bool gen_rivers = (spflags & MGV7_RIDGES) && node_max.Y >= water_level - 16 &&
!gen_floatlands;
if (gen_rivers) {
noise_ridge->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
noise_ridge_uwater->perlinMap2D(node_min.X, node_min.Z);
noise_ridge->noiseMap3D(node_min.X, node_min.Y - 1, node_min.Z);
noise_ridge_uwater->noiseMap2D(node_min.X, node_min.Z);
}
//// Place nodes

24
src/mapgen/mapgen_valleys.cpp
View File

@@ -280,15 +280,15 @@ void MapgenValleys::makeChunk(BlockMakeData *data)
int MapgenValleys::getSpawnLevelAtPoint(v2s16 p)
{
// Check if in a river channel
float n_rivers = NoisePerlin2D(&noise_rivers->np, p.X, p.Y, seed);
float n_rivers = NoiseFractal2D(&noise_rivers->np, p.X, p.Y, seed);
if (std::fabs(n_rivers) <= river_size_factor)
// Unsuitable spawn point
return MAX_MAP_GENERATION_LIMIT;
float n_slope = NoisePerlin2D(&noise_inter_valley_slope->np, p.X, p.Y, seed);
float n_terrain_height = NoisePerlin2D(&noise_terrain_height->np, p.X, p.Y, seed);
float n_valley = NoisePerlin2D(&noise_valley_depth->np, p.X, p.Y, seed);
float n_valley_profile = NoisePerlin2D(&noise_valley_profile->np, p.X, p.Y, seed);
float n_slope = NoiseFractal2D(&noise_inter_valley_slope->np, p.X, p.Y, seed);
float n_terrain_height = NoiseFractal2D(&noise_terrain_height->np, p.X, p.Y, seed);
float n_valley = NoiseFractal2D(&noise_valley_depth->np, p.X, p.Y, seed);
float n_valley_profile = NoiseFractal2D(&noise_valley_profile->np, p.X, p.Y, seed);
float valley_d = n_valley * n_valley;
float base = n_terrain_height + valley_d;
@@ -309,7 +309,7 @@ int MapgenValleys::getSpawnLevelAtPoint(v2s16 p)
// Starting spawn search at max_spawn_y + 128 ensures 128 nodes of open
// space above spawn position. Avoids spawning in possibly sealed voids.
for (s16 y = max_spawn_y + 128; y >= water_level; y--) {
float n_fill = NoisePerlin3D(&noise_inter_valley_fill->np, p.X, y, p.Y, seed);
float n_fill = NoiseFractal3D(&noise_inter_valley_fill->np, p.X, y, p.Y, seed);
float surface_delta = (float)y - surface_y;
float density = slope * n_fill - surface_delta;
@@ -336,13 +336,13 @@ int MapgenValleys::generateTerrain()
MapNode n_stone(c_stone);
MapNode n_water(c_water_source);
noise_inter_valley_slope->perlinMap2D(node_min.X, node_min.Z);
noise_rivers->perlinMap2D(node_min.X, node_min.Z);
noise_terrain_height->perlinMap2D(node_min.X, node_min.Z);
noise_valley_depth->perlinMap2D(node_min.X, node_min.Z);
noise_valley_profile->perlinMap2D(node_min.X, node_min.Z);
noise_inter_valley_slope->noiseMap2D(node_min.X, node_min.Z);
noise_rivers->noiseMap2D(node_min.X, node_min.Z);
noise_terrain_height->noiseMap2D(node_min.X, node_min.Z);
noise_valley_depth->noiseMap2D(node_min.X, node_min.Z);
noise_valley_profile->noiseMap2D(node_min.X, node_min.Z);
noise_inter_valley_fill->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
noise_inter_valley_fill->noiseMap3D(node_min.X, node_min.Y - 1, node_min.Z);
const v3s32 &em = vm->m_area.getExtent();
s16 surface_max_y = -MAX_MAP_GENERATION_LIMIT;

16
src/mapgen/mg_biome.cpp
View File

@@ -165,14 +165,14 @@ BiomeGen *BiomeGenOriginal::clone(BiomeManager *biomemgr) const
float BiomeGenOriginal::calcHeatAtPoint(v3s16 pos) const
{
return NoisePerlin2D(&m_params->np_heat, pos.X, pos.Z, m_params->seed) +
NoisePerlin2D(&m_params->np_heat_blend, pos.X, pos.Z, m_params->seed);
return NoiseFractal2D(&m_params->np_heat, pos.X, pos.Z, m_params->seed) +
NoiseFractal2D(&m_params->np_heat_blend, pos.X, pos.Z, m_params->seed);
}
float BiomeGenOriginal::calcHumidityAtPoint(v3s16 pos) const
{
return NoisePerlin2D(&m_params->np_humidity, pos.X, pos.Z, m_params->seed) +
NoisePerlin2D(&m_params->np_humidity_blend, pos.X, pos.Z, m_params->seed);
return NoiseFractal2D(&m_params->np_humidity, pos.X, pos.Z, m_params->seed) +
NoiseFractal2D(&m_params->np_humidity_blend, pos.X, pos.Z, m_params->seed);
}
Biome *BiomeGenOriginal::calcBiomeAtPoint(v3s16 pos) const
@@ -185,10 +185,10 @@ void BiomeGenOriginal::calcBiomeNoise(v3s16 pmin)
{
m_pmin = pmin;
noise_heat->perlinMap2D(pmin.X, pmin.Z);
noise_humidity->perlinMap2D(pmin.X, pmin.Z);
noise_heat_blend->perlinMap2D(pmin.X, pmin.Z);
noise_humidity_blend->perlinMap2D(pmin.X, pmin.Z);
noise_heat->noiseMap2D(pmin.X, pmin.Z);
noise_humidity->noiseMap2D(pmin.X, pmin.Z);
noise_heat_blend->noiseMap2D(pmin.X, pmin.Z);
noise_humidity_blend->noiseMap2D(pmin.X, pmin.Z);
for (s32 i = 0; i < m_csize.X * m_csize.Z; i++) {
noise_heat->result[i] += noise_heat_blend->result[i];

2
src/mapgen/mg_decoration.cpp
View File

@@ -148,7 +148,7 @@ void Decoration::placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
bool cover = false;
// Amount of decorations
float nval = (flags & DECO_USE_NOISE) ?
NoisePerlin2D(&np, p2d_min.X + sidelen / 2, p2d_min.Y + sidelen / 2, mapseed) :
NoiseFractal2D(&np, p2d_min.X + sidelen / 2, p2d_min.Y + sidelen / 2, mapseed) :
fill_ratio;
u32 deco_count = 0;

22
src/mapgen/mg_ore.cpp
View File

@@ -150,7 +150,7 @@ void OreScatter::generate(MMVManip *vm, int mapseed, u32 blockseed,
int z0 = pr.range(nmin.Z, nmax.Z - csize + 1);
if ((flags & OREFLAG_USE_NOISE) &&
(NoisePerlin3D(&np, x0, y0, z0, mapseed) < nthresh))
(NoiseFractal3D(&np, x0, y0, z0, mapseed) < nthresh))
continue;
if (biomemap && !biomes.empty()) {
@@ -212,7 +212,7 @@ void OreSheet::generate(MMVManip *vm, int mapseed, u32 blockseed,
noise = new Noise(&np, 0, sx, sz);
}
noise->seed = mapseed + y_start;
noise->perlinMap2D(nmin.X, nmin.Z);
noise->noiseMap2D(nmin.X, nmin.Z);
size_t index = 0;
for (int z = nmin.Z; z <= nmax.Z; z++)
@@ -286,7 +286,7 @@ void OrePuff::generate(MMVManip *vm, int mapseed, u32 blockseed,
}
noise->seed = mapseed + y_start;
noise->perlinMap2D(nmin.X, nmin.Z);
noise->noiseMap2D(nmin.X, nmin.Z);
bool noise_generated = false;
size_t index = 0;
@@ -304,8 +304,8 @@ void OrePuff::generate(MMVManip *vm, int mapseed, u32 blockseed,
if (!noise_generated) {
noise_generated = true;
noise_puff_top->perlinMap2D(nmin.X, nmin.Z);
noise_puff_bottom->perlinMap2D(nmin.X, nmin.Z);
noise_puff_top->noiseMap2D(nmin.X, nmin.Z);
noise_puff_bottom->noiseMap2D(nmin.X, nmin.Z);
}
float ntop = noise_puff_top->result[index];
@@ -393,7 +393,7 @@ void OreBlob::generate(MMVManip *vm, int mapseed, u32 blockseed,
// This simple optimization makes calls 6x faster on average
if (!noise_generated) {
noise_generated = true;
noise->perlinMap3D(x0, y0, z0);
noise->noiseMap3D(x0, y0, z0);
}
float noiseval = noise->result[index];
@@ -443,7 +443,7 @@ void OreVein::generate(MMVManip *vm, int mapseed, u32 blockseed,
int sizex = nmax.X - nmin.X + 1;
int sizey = nmax.Y - nmin.Y + 1;
// Because this ore uses 3D noise the perlinmap Y size can be different in
// Because this ore uses 3D noise the noisemap Y size can be different in
// different mapchunks due to ore Y limits. So recreate the noise objects
// if Y size has changed.
// Because these noise objects are created multiple times for this ore type
@@ -478,8 +478,8 @@ void OreVein::generate(MMVManip *vm, int mapseed, u32 blockseed,
// Same lazy generation optimization as in OreBlob
if (!noise_generated) {
noise_generated = true;
noise->perlinMap3D(nmin.X, nmin.Y, nmin.Z);
noise2->perlinMap3D(nmin.X, nmin.Y, nmin.Z);
noise->noiseMap3D(nmin.X, nmin.Y, nmin.Z);
noise2->noiseMap3D(nmin.X, nmin.Y, nmin.Z);
}
// randval ranges from -1..1
@@ -532,7 +532,7 @@ void OreStratum::generate(MMVManip *vm, int mapseed, u32 blockseed,
int sz = nmax.Z - nmin.Z + 1;
noise = new Noise(&np, 0, sx, sz);
}
noise->perlinMap2D(nmin.X, nmin.Z);
noise->noiseMap2D(nmin.X, nmin.Z);
}
if (flags & OREFLAG_USE_NOISE2) {
@@ -541,7 +541,7 @@ void OreStratum::generate(MMVManip *vm, int mapseed, u32 blockseed,
int sz = nmax.Z - nmin.Z + 1;
noise_stratum_thickness = new Noise(&np_stratum_thickness, 0, sx, sz);
}
noise_stratum_thickness->perlinMap2D(nmin.X, nmin.Z);
noise_stratum_thickness->noiseMap2D(nmin.X, nmin.Z);
}
size_t index = 0;