Mapgen: Remove '#include treegen.h' from non-mgv6 mapgens

[minetest.git] / src / cavegen.h

diff --git a/src/cavegen.h b/src/cavegen.h
index 74cd0b41658f6f9b2adca8d10aa53c203f791191..e322c181c625c1e2e5fd6433a1291fce90297496 100644 (file)
--- a/src/cavegen.h
+++ b/src/cavegen.h
@@ -25,23 +25,108 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 class GenerateNotifier;
 
+/*
+       CavesNoiseIntersection is a cave digging algorithm that carves smooth,
+       web-like, continuous tunnels at points where the density of the intersection
+       between two separate 3d noises is above a certain value.  This value,
+       cave_width, can be modified to set the effective width of these tunnels.
+
+       This algorithm is relatively heavyweight, taking ~80ms to generate an
+       80x80x80 chunk of map on a modern processor.  Use sparingly!
+
+       TODO(hmmmm): Remove dependency on biomes
+       TODO(hmmmm): Find alternative to overgeneration as solution for sunlight issue
+*/
+class CavesNoiseIntersection {
+public:
+       CavesNoiseIntersection(INodeDefManager *nodedef, BiomeManager *biomemgr,
+               v3s16 chunksize, NoiseParams *np_cave1, NoiseParams *np_cave2,
+               s32 seed, float cave_width);
+       ~CavesNoiseIntersection();
+
+       void generateCaves(MMVManip *vm, v3s16 nmin, v3s16 nmax, u8 *biomemap);
+
+private:
+       INodeDefManager *m_ndef;
+       BiomeManager *m_bmgr;
+
+       // configurable parameters
+       v3s16 m_csize;
+       float m_cave_width;
+
+       // intermediate state variables
+       u16 m_ystride;
+       u16 m_zstride_1d;
+
+       Noise *noise_cave1;
+       Noise *noise_cave2;
+};
+
+/*
+       CavernsNoise is a cave digging algorithm
+*/
+class CavernsNoise {
+public:
+       CavernsNoise(INodeDefManager *nodedef, v3s16 chunksize, NoiseParams *np_cavern,
+       s32 seed, float cavern_limit, float cavern_taper, float cavern_threshold);
+       ~CavernsNoise();
+
+       bool generateCaverns(MMVManip *vm, v3s16 nmin, v3s16 nmax);
+
+private:
+       INodeDefManager *m_ndef;
+
+       // configurable parameters
+       v3s16 m_csize;
+       float m_cavern_limit;
+       float m_cavern_taper;
+       float m_cavern_threshold;
+
+       // intermediate state variables
+       u16 m_ystride;
+       u16 m_zstride_1d;
+
+       Noise *noise_cavern;
+
+       content_t c_water_source;
+       content_t c_lava_source;
+};
+
+/*
+       CavesRandomWalk is an implementation of a cave-digging algorithm that
+       operates on the principle of a "random walk" to approximate the stochiastic
+       activity of cavern development.
+
+       In summary, this algorithm works by carving a randomly sized tunnel in a
+       random direction a random amount of times, randomly varying in width.
+       All randomness here is uniformly distributed; alternative distributions have
+       not yet been implemented.
+
+       This algorithm is very fast, executing in less than 1ms on average for an
+       80x80x80 chunk of map on a modern processor.
+*/
 class CavesRandomWalk {
 public:
-       Mapgen *mg;
        MMVManip *vm;
        INodeDefManager *ndef;
+       GenerateNotifier *gennotify;
        s16 *heightmap;
 
-       // variables
+       // configurable parameters
+       s32 seed;
+       int water_level;
        int lava_depth;
        NoiseParams *np_caveliquids;
 
+       // intermediate state variables
+       u16 ystride;
+
        s16 min_tunnel_diameter;
        s16 max_tunnel_diameter;
        u16 tunnel_routepoints;
-       int dswitchint;
        int part_max_length_rs;
 
+       bool large_cave;
        bool large_cave_is_flat;
        bool flooded;
 
@@ -62,15 +147,27 @@ class CavesRandomWalk {
 
        content_t c_water_source;
        content_t c_lava_source;
-       content_t c_ice;
 
-       int water_level;
-       u16 ystride;
+       // ndef is a mandatory parameter.
+       // If gennotify is NULL, generation events are not logged.
+       CavesRandomWalk(INodeDefManager *ndef,
+               GenerateNotifier *gennotify = NULL,
+               s32 seed = 0,
+               int water_level = 1,
+               content_t water_source = CONTENT_IGNORE,
+               content_t lava_source = CONTENT_IGNORE);
 
-       CavesRandomWalk(Mapgen *mg, PseudoRandom *ps);
-       void makeCave(v3s16 nmin, v3s16 nmax, int max_stone_height);
+       // vm and ps are mandatory parameters.
+       // If heightmap is NULL, the surface level at all points is assumed to
+       // be water_level.
+       void makeCave(MMVManip *vm, v3s16 nmin, v3s16 nmax, PseudoRandom *ps,
+               bool is_large_cave, int max_stone_height, s16 *heightmap);
+
+private:
        void makeTunnel(bool dirswitch);
        void carveRoute(v3f vec, float f, bool randomize_xz);
+
+       inline bool isPosAboveSurface(v3s16 p);
 };
 
 /*
@@ -94,17 +191,18 @@ class CavesV6 {
        PseudoRandom *ps;
        PseudoRandom *ps2;
 
+       // configurable parameters
        s16 *heightmap;
        content_t c_water_source;
        content_t c_lava_source;
        int water_level;
 
+       // intermediate state variables
        u16 ystride;
 
        s16 min_tunnel_diameter;
        s16 max_tunnel_diameter;
        u16 tunnel_routepoints;
-       int dswitchint;
        int part_max_length_rs;
 
        bool large_cave;
@@ -140,6 +238,8 @@ class CavesV6 {
 private:
        void makeTunnel(bool dirswitch);
        void carveRoute(v3f vec, float f, bool randomize_xz, bool tunnel_above_ground);
+
+       inline s16 getSurfaceFromHeightmap(v3s16 p);
 };
 
 #endif