Skip to content

Commit 0a8af88

Browse files
paramatparamat
committedFeb 2, 2016
Mgv5/v7/flat/fractal: Move tunnel noise calculation into generateCaves
Tunnel 3D noises are only calculated when solid terrain is present in mapchunk, avoiding large amounts of unnecessary calculations Change 'int' to 's16' in calculateNoise Change 'i' to 'vi' for voxelmanip indexes for consistency Keep 'u32 index3d' local to a smaller part of tunnel code Mgv7: Don't call CaveV7 if no solid terrain in mapchunk Give 'open' bool a more descriptive name
·
5.11.00.4.14
1 parent 80c7612 commit 0a8af88

File tree

4 files changed

+172
-166
lines changed

4 files changed

+172
-166
lines changed
 

‎src/mapgen_flat.cpp

+44-44
Original file line numberDiff line numberDiff line change
@@ -323,20 +323,16 @@ void MapgenFlat::makeChunk(BlockMakeData *data)
323323
void MapgenFlat::calculateNoise()
324324
{
325325
//TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
326-
int x = node_min.X;
327-
int y = node_min.Y - 1;
328-
int z = node_min.Z;
326+
s16 x = node_min.X;
327+
s16 z = node_min.Z;
329328

330329
if ((spflags & MGFLAT_LAKES) || (spflags & MGFLAT_HILLS))
331330
noise_terrain->perlinMap2D(x, z);
332331

333-
noise_filler_depth->perlinMap2D(x, z);
334-
335-
if (flags & MG_CAVES) {
336-
noise_cave1->perlinMap3D(x, y, z);
337-
noise_cave2->perlinMap3D(x, y, z);
338-
}
332+
// Cave noises are calculated in generateCaves()
333+
// only if solid terrain is present in mapchunk
339334

335+
noise_filler_depth->perlinMap2D(x, z);
340336
noise_heat->perlinMap2D(x, z);
341337
noise_humidity->perlinMap2D(x, z);
342338
noise_heat_blend->perlinMap2D(x, z);
@@ -550,41 +546,45 @@ void MapgenFlat::dustTopNodes()
550546

551547
void MapgenFlat::generateCaves(s16 max_stone_y)
552548
{
553-
if (max_stone_y >= node_min.Y) {
554-
v3s16 em = vm->m_area.getExtent();
555-
u32 index2d = 0;
556-
u32 index3d;
557-
558-
for (s16 z = node_min.Z; z <= node_max.Z; z++)
559-
for (s16 x = node_min.X; x <= node_max.X; x++, index2d++) {
560-
bool open = false; // Is column open to overground
561-
u32 vi = vm->m_area.index(x, node_max.Y + 1, z);
562-
index3d = (z - node_min.Z) * zstride + (csize.Y + 1) * ystride +
563-
(x - node_min.X);
564-
// Biome of column
565-
Biome *biome = (Biome *)bmgr->getRaw(biomemap[index2d]);
566-
567-
for (s16 y = node_max.Y + 1; y >= node_min.Y - 1;
568-
y--, index3d -= ystride, vm->m_area.add_y(em, vi, -1)) {
569-
content_t c = vm->m_data[vi].getContent();
570-
if (c == CONTENT_AIR || c == biome->c_water_top ||
571-
c == biome->c_water) {
572-
open = true;
573-
continue;
574-
}
575-
// Ground
576-
float d1 = contour(noise_cave1->result[index3d]);
577-
float d2 = contour(noise_cave2->result[index3d]);
578-
if (d1 * d2 > 0.3f && ndef->get(c).is_ground_content) {
579-
// In tunnel and ground content, excavate
580-
vm->m_data[vi] = MapNode(CONTENT_AIR);
581-
} else if (open && (c == biome->c_filler || c == biome->c_stone)) {
582-
// Tunnel entrance floor
583-
vm->m_data[vi] = MapNode(biome->c_top);
584-
open = false;
585-
} else {
586-
open = false;
587-
}
549+
if (max_stone_y < node_min.Y)
550+
return;
551+
552+
noise_cave1->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
553+
noise_cave2->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
554+
555+
v3s16 em = vm->m_area.getExtent();
556+
u32 index2d = 0;
557+
558+
for (s16 z = node_min.Z; z <= node_max.Z; z++)
559+
for (s16 x = node_min.X; x <= node_max.X; x++, index2d++) {
560+
bool column_is_open = false; // Is column open to overground
561+
u32 vi = vm->m_area.index(x, node_max.Y + 1, z);
562+
u32 index3d = (z - node_min.Z) * zstride + (csize.Y + 1) * ystride +
563+
(x - node_min.X);
564+
// Biome of column
565+
Biome *biome = (Biome *)bmgr->getRaw(biomemap[index2d]);
566+
567+
for (s16 y = node_max.Y + 1; y >= node_min.Y - 1;
568+
y--, index3d -= ystride, vm->m_area.add_y(em, vi, -1)) {
569+
content_t c = vm->m_data[vi].getContent();
570+
if (c == CONTENT_AIR || c == biome->c_water_top ||
571+
c == biome->c_water) {
572+
column_is_open = true;
573+
continue;
574+
}
575+
// Ground
576+
float d1 = contour(noise_cave1->result[index3d]);
577+
float d2 = contour(noise_cave2->result[index3d]);
578+
if (d1 * d2 > 0.3f && ndef->get(c).is_ground_content) {
579+
// In tunnel and ground content, excavate
580+
vm->m_data[vi] = MapNode(CONTENT_AIR);
581+
} else if (column_is_open &&
582+
(c == biome->c_filler || c == biome->c_stone)) {
583+
// Tunnel entrance floor
584+
vm->m_data[vi] = MapNode(biome->c_top);
585+
column_is_open = false;
586+
} else {
587+
column_is_open = false;
588588
}
589589
}
590590
}

‎src/mapgen_fractal.cpp

+44-43
Original file line numberDiff line numberDiff line change
@@ -339,18 +339,15 @@ void MapgenFractal::makeChunk(BlockMakeData *data)
339339
void MapgenFractal::calculateNoise()
340340
{
341341
//TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
342-
int x = node_min.X;
343-
int y = node_min.Y - 1;
344-
int z = node_min.Z;
342+
s16 x = node_min.X;
343+
s16 z = node_min.Z;
345344

346345
noise_seabed->perlinMap2D(x, z);
347-
noise_filler_depth->perlinMap2D(x, z);
348346

349-
if (flags & MG_CAVES) {
350-
noise_cave1->perlinMap3D(x, y, z);
351-
noise_cave2->perlinMap3D(x, y, z);
352-
}
347+
// Cave noises are calculated in generateCaves()
348+
// only if solid terrain is present in mapchunk
353349

350+
noise_filler_depth->perlinMap2D(x, z);
354351
noise_heat->perlinMap2D(x, z);
355352
noise_humidity->perlinMap2D(x, z);
356353
noise_heat_blend->perlinMap2D(x, z);
@@ -673,41 +670,45 @@ void MapgenFractal::dustTopNodes()
673670

674671
void MapgenFractal::generateCaves(s16 max_stone_y)
675672
{
676-
if (max_stone_y >= node_min.Y) {
677-
v3s16 em = vm->m_area.getExtent();
678-
u32 index2d = 0;
679-
u32 index3d;
680-
681-
for (s16 z = node_min.Z; z <= node_max.Z; z++)
682-
for (s16 x = node_min.X; x <= node_max.X; x++, index2d++) {
683-
bool open = false; // Is column open to overground
684-
u32 vi = vm->m_area.index(x, node_max.Y + 1, z);
685-
index3d = (z - node_min.Z) * zstride + (csize.Y + 1) * ystride +
686-
(x - node_min.X);
687-
// Biome of column
688-
Biome *biome = (Biome *)bmgr->getRaw(biomemap[index2d]);
689-
690-
for (s16 y = node_max.Y + 1; y >= node_min.Y - 1;
691-
y--, index3d -= ystride, vm->m_area.add_y(em, vi, -1)) {
692-
content_t c = vm->m_data[vi].getContent();
693-
if (c == CONTENT_AIR || c == biome->c_water_top ||
694-
c == biome->c_water) {
695-
open = true;
696-
continue;
697-
}
698-
// Ground
699-
float d1 = contour(noise_cave1->result[index3d]);
700-
float d2 = contour(noise_cave2->result[index3d]);
701-
if (d1 * d2 > 0.3f && ndef->get(c).is_ground_content) {
702-
// In tunnel and ground content, excavate
703-
vm->m_data[vi] = MapNode(CONTENT_AIR);
704-
} else if (open && (c == biome->c_filler || c == biome->c_stone)) {
705-
// Tunnel entrance floor
706-
vm->m_data[vi] = MapNode(biome->c_top);
707-
open = false;
708-
} else {
709-
open = false;
710-
}
673+
if (max_stone_y < node_min.Y)
674+
return;
675+
676+
noise_cave1->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
677+
noise_cave2->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
678+
679+
v3s16 em = vm->m_area.getExtent();
680+
u32 index2d = 0;
681+
682+
for (s16 z = node_min.Z; z <= node_max.Z; z++)
683+
for (s16 x = node_min.X; x <= node_max.X; x++, index2d++) {
684+
bool column_is_open = false; // Is column open to overground
685+
u32 vi = vm->m_area.index(x, node_max.Y + 1, z);
686+
u32 index3d = (z - node_min.Z) * zstride + (csize.Y + 1) * ystride +
687+
(x - node_min.X);
688+
// Biome of column
689+
Biome *biome = (Biome *)bmgr->getRaw(biomemap[index2d]);
690+
691+
for (s16 y = node_max.Y + 1; y >= node_min.Y - 1;
692+
y--, index3d -= ystride, vm->m_area.add_y(em, vi, -1)) {
693+
content_t c = vm->m_data[vi].getContent();
694+
if (c == CONTENT_AIR || c == biome->c_water_top ||
695+
c == biome->c_water) {
696+
column_is_open = true;
697+
continue;
698+
}
699+
// Ground
700+
float d1 = contour(noise_cave1->result[index3d]);
701+
float d2 = contour(noise_cave2->result[index3d]);
702+
if (d1 * d2 > 0.3f && ndef->get(c).is_ground_content) {
703+
// In tunnel and ground content, excavate
704+
vm->m_data[vi] = MapNode(CONTENT_AIR);
705+
} else if (column_is_open &&
706+
(c == biome->c_filler || c == biome->c_stone)) {
707+
// Tunnel entrance floor
708+
vm->m_data[vi] = MapNode(biome->c_top);
709+
column_is_open = false;
710+
} else {
711+
column_is_open = false;
711712
}
712713
}
713714
}

‎src/mapgen_v5.cpp

+31-29
Original file line numberDiff line numberDiff line change
@@ -322,18 +322,16 @@ void MapgenV5::makeChunk(BlockMakeData *data)
322322
void MapgenV5::calculateNoise()
323323
{
324324
//TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
325-
int x = node_min.X;
326-
int y = node_min.Y - 1;
327-
int z = node_min.Z;
325+
s16 x = node_min.X;
326+
s16 y = node_min.Y - 1;
327+
s16 z = node_min.Z;
328328

329329
noise_factor->perlinMap2D(x, z);
330330
noise_height->perlinMap2D(x, z);
331331
noise_ground->perlinMap3D(x, y, z);
332332

333-
if (flags & MG_CAVES) {
334-
noise_cave1->perlinMap3D(x, y, z);
335-
noise_cave2->perlinMap3D(x, y, z);
336-
}
333+
// Cave noises are calculated in generateCaves()
334+
// only if solid terrain is present in mapchunk
337335

338336
noise_filler_depth->perlinMap2D(x, z);
339337
noise_heat->perlinMap2D(x, z);
@@ -377,9 +375,9 @@ int MapgenV5::generateBaseTerrain()
377375

378376
for (s16 z=node_min.Z; z<=node_max.Z; z++) {
379377
for (s16 y=node_min.Y - 1; y<=node_max.Y + 1; y++) {
380-
u32 i = vm->m_area.index(node_min.X, y, z);
381-
for (s16 x=node_min.X; x<=node_max.X; x++, i++, index++, index2d++) {
382-
if (vm->m_data[i].getContent() != CONTENT_IGNORE)
378+
u32 vi = vm->m_area.index(node_min.X, y, z);
379+
for (s16 x=node_min.X; x<=node_max.X; x++, vi++, index++, index2d++) {
380+
if (vm->m_data[vi].getContent() != CONTENT_IGNORE)
383381
continue;
384382

385383
float f = 0.55 + noise_factor->result[index2d];
@@ -391,11 +389,11 @@ int MapgenV5::generateBaseTerrain()
391389

392390
if (noise_ground->result[index] * f < y - h) {
393391
if (y <= water_level)
394-
vm->m_data[i] = MapNode(c_water_source);
392+
vm->m_data[vi] = MapNode(c_water_source);
395393
else
396-
vm->m_data[i] = MapNode(CONTENT_AIR);
394+
vm->m_data[vi] = MapNode(CONTENT_AIR);
397395
} else {
398-
vm->m_data[i] = MapNode(c_stone);
396+
vm->m_data[vi] = MapNode(c_stone);
399397
if (y > stone_surface_max_y)
400398
stone_surface_max_y = y;
401399
}
@@ -508,22 +506,26 @@ MgStoneType MapgenV5::generateBiomes(float *heat_map, float *humidity_map)
508506

509507
void MapgenV5::generateCaves(int max_stone_y)
510508
{
511-
if (max_stone_y >= node_min.Y) {
512-
u32 index = 0;
513-
514-
for (s16 z = node_min.Z; z <= node_max.Z; z++)
515-
for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
516-
u32 i = vm->m_area.index(node_min.X, y, z);
517-
for (s16 x = node_min.X; x <= node_max.X; x++, i++, index++) {
518-
float d1 = contour(noise_cave1->result[index]);
519-
float d2 = contour(noise_cave2->result[index]);
520-
if (d1 * d2 > 0.125f) {
521-
content_t c = vm->m_data[i].getContent();
522-
if (!ndef->get(c).is_ground_content || c == CONTENT_AIR)
523-
continue;
524-
525-
vm->m_data[i] = MapNode(CONTENT_AIR);
526-
}
509+
if (max_stone_y < node_min.Y)
510+
return;
511+
512+
noise_cave1->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
513+
noise_cave2->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
514+
515+
u32 index = 0;
516+
517+
for (s16 z = node_min.Z; z <= node_max.Z; z++)
518+
for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
519+
u32 vi = vm->m_area.index(node_min.X, y, z);
520+
for (s16 x = node_min.X; x <= node_max.X; x++, vi++, index++) {
521+
float d1 = contour(noise_cave1->result[index]);
522+
float d2 = contour(noise_cave2->result[index]);
523+
if (d1 * d2 > 0.125f) {
524+
content_t c = vm->m_data[vi].getContent();
525+
if (!ndef->get(c).is_ground_content || c == CONTENT_AIR)
526+
continue;
527+
528+
vm->m_data[vi] = MapNode(CONTENT_AIR);
527529
}
528530
}
529531
}

‎src/mapgen_v7.cpp

+53-50
Original file line numberDiff line numberDiff line change
@@ -345,9 +345,9 @@ void MapgenV7::makeChunk(BlockMakeData *data)
345345
void MapgenV7::calculateNoise()
346346
{
347347
//TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
348-
int x = node_min.X;
349-
int y = node_min.Y - 1;
350-
int z = node_min.Z;
348+
s16 x = node_min.X;
349+
s16 y = node_min.Y - 1;
350+
s16 z = node_min.Z;
351351

352352
noise_terrain_persist->perlinMap2D(x, z);
353353
float *persistmap = noise_terrain_persist->result;
@@ -356,17 +356,16 @@ void MapgenV7::calculateNoise()
356356
noise_terrain_alt->perlinMap2D(x, z, persistmap);
357357
noise_height_select->perlinMap2D(x, z);
358358

359-
if (flags & MG_CAVES) {
360-
noise_cave1->perlinMap3D(x, y, z);
361-
noise_cave2->perlinMap3D(x, y, z);
362-
}
363-
364359
if ((spflags & MGV7_RIDGES) && node_max.Y >= water_level) {
365360
noise_ridge->perlinMap3D(x, y, z);
366361
noise_ridge_uwater->perlinMap2D(x, z);
367362
}
368363

364+
// Cave noises are calculated in generateCaves()
365+
// only if solid terrain is present in mapchunk
366+
369367
// Mountain noises are calculated in generateMountainTerrain()
368+
// only if solid terrain surface dips into mapchunk
370369

371370
noise_filler_depth->perlinMap2D(x, z);
372371
noise_heat->perlinMap2D(x, z);
@@ -527,17 +526,17 @@ void MapgenV7::generateBaseTerrain(s16 *stone_surface_min_y, s16 *stone_surface_
527526
if (surface_y > surface_max_y)
528527
surface_max_y = surface_y;
529528

530-
u32 i = vm->m_area.index(x, node_min.Y - 1, z);
529+
u32 vi = vm->m_area.index(x, node_min.Y - 1, z);
531530
for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
532-
if (vm->m_data[i].getContent() == CONTENT_IGNORE) {
531+
if (vm->m_data[vi].getContent() == CONTENT_IGNORE) {
533532
if (y <= surface_y)
534-
vm->m_data[i] = n_stone;
533+
vm->m_data[vi] = n_stone;
535534
else if (y <= water_level)
536-
vm->m_data[i] = n_water;
535+
vm->m_data[vi] = n_water;
537536
else
538-
vm->m_data[i] = n_air;
537+
vm->m_data[vi] = n_air;
539538
}
540-
vm->m_area.add_y(em, i, 1);
539+
vm->m_area.add_y(em, vi, 1);
541540
}
542541
}
543542

@@ -585,7 +584,7 @@ void MapgenV7::generateRidgeTerrain()
585584
MapNode n_water(c_water_source);
586585
MapNode n_air(CONTENT_AIR);
587586
u32 index = 0;
588-
float width = 0.2; // TODO: figure out acceptable perlin noise values
587+
float width = 0.2;
589588

590589
for (s16 z = node_min.Z; z <= node_max.Z; z++)
591590
for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
@@ -862,41 +861,45 @@ void MapgenV7::addTopNodes()
862861

863862
void MapgenV7::generateCaves(s16 max_stone_y)
864863
{
865-
if (max_stone_y >= node_min.Y) {
866-
v3s16 em = vm->m_area.getExtent();
867-
u32 index2d = 0;
868-
u32 index3d;
869-
870-
for (s16 z = node_min.Z; z <= node_max.Z; z++)
871-
for (s16 x = node_min.X; x <= node_max.X; x++, index2d++) {
872-
bool open = false; // Is column open to overground
873-
u32 vi = vm->m_area.index(x, node_max.Y + 1, z);
874-
index3d = (z - node_min.Z) * zstride + (csize.Y + 1) * ystride +
875-
(x - node_min.X);
876-
// Biome of column
877-
Biome *biome = (Biome *)bmgr->getRaw(biomemap[index2d]);
878-
879-
for (s16 y = node_max.Y + 1; y >= node_min.Y - 1;
880-
y--, index3d -= ystride, vm->m_area.add_y(em, vi, -1)) {
881-
content_t c = vm->m_data[vi].getContent();
882-
if (c == CONTENT_AIR || c == biome->c_water_top ||
883-
c == biome->c_water) {
884-
open = true;
885-
continue;
886-
}
887-
// Ground
888-
float d1 = contour(noise_cave1->result[index3d]);
889-
float d2 = contour(noise_cave2->result[index3d]);
890-
if (d1 * d2 > 0.3f && ndef->get(c).is_ground_content) {
891-
// In tunnel and ground content, excavate
892-
vm->m_data[vi] = MapNode(CONTENT_AIR);
893-
} else if (open && (c == biome->c_filler || c == biome->c_stone)) {
894-
// Tunnel entrance floor
895-
vm->m_data[vi] = MapNode(biome->c_top);
896-
open = false;
897-
} else {
898-
open = false;
899-
}
864+
if (max_stone_y < node_min.Y)
865+
return;
866+
867+
noise_cave1->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
868+
noise_cave2->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
869+
870+
v3s16 em = vm->m_area.getExtent();
871+
u32 index2d = 0;
872+
873+
for (s16 z = node_min.Z; z <= node_max.Z; z++)
874+
for (s16 x = node_min.X; x <= node_max.X; x++, index2d++) {
875+
bool column_is_open = false; // Is column open to overground
876+
u32 vi = vm->m_area.index(x, node_max.Y + 1, z);
877+
u32 index3d = (z - node_min.Z) * zstride + (csize.Y + 1) * ystride +
878+
(x - node_min.X);
879+
// Biome of column
880+
Biome *biome = (Biome *)bmgr->getRaw(biomemap[index2d]);
881+
882+
for (s16 y = node_max.Y + 1; y >= node_min.Y - 1;
883+
y--, index3d -= ystride, vm->m_area.add_y(em, vi, -1)) {
884+
content_t c = vm->m_data[vi].getContent();
885+
if (c == CONTENT_AIR || c == biome->c_water_top ||
886+
c == biome->c_water) {
887+
column_is_open = true;
888+
continue;
889+
}
890+
// Ground
891+
float d1 = contour(noise_cave1->result[index3d]);
892+
float d2 = contour(noise_cave2->result[index3d]);
893+
if (d1 * d2 > 0.3f && ndef->get(c).is_ground_content) {
894+
// In tunnel and ground content, excavate
895+
vm->m_data[vi] = MapNode(CONTENT_AIR);
896+
} else if (column_is_open &&
897+
(c == biome->c_filler || c == biome->c_stone)) {
898+
// Tunnel entrance floor
899+
vm->m_data[vi] = MapNode(biome->c_top);
900+
column_is_open = false;
901+
} else {
902+
column_is_open = false;
900903
}
901904
}
902905
}

0 commit comments

Comments
 (0)
Please sign in to comment.