src/mapgen/mg_biome.h

   1 /*
   2 Minetest
   3 Copyright (C) 2014-2020 paramat
   4 Copyright (C) 2014-2016 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #pragma once
  22
  23 #include "objdef.h"
  24 #include "nodedef.h"
  25 #include "noise.h"
  26
  27 class Server;
  28 class Settings;
  29 class BiomeManager;
  30
  31 ////
  32 //// Biome
  33 ////
  34
  35 typedef u16 biome_t;
  36
  37 #define BIOME_NONE ((biome_t)0)
  38
  39 enum BiomeType {
  40         BIOMETYPE_NORMAL,
  41 };
  42
  43 class Biome : public ObjDef, public NodeResolver {
  44 public:
  45         ObjDef *clone() const;
  46
  47         u32 flags;
  48
  49         content_t c_top;
  50         content_t c_filler;
  51         content_t c_stone;
  52         content_t c_water_top;
  53         content_t c_water;
  54         content_t c_river_water;
  55         content_t c_riverbed;
  56         content_t c_dust;
  57         std::vector<content_t> c_cave_liquid;
  58         content_t c_dungeon;
  59         content_t c_dungeon_alt;
  60         content_t c_dungeon_stair;
  61
  62         s16 depth_top;
  63         s16 depth_filler;
  64         s16 depth_water_top;
  65         s16 depth_riverbed;
  66
  67         v3s16 min_pos;
  68         v3s16 max_pos;
  69         float heat_point;
  70         float humidity_point;
  71         s16 vertical_blend;
  72
  73         virtual void resolveNodeNames();
  74 };
  75
  76
  77 ////
  78 //// BiomeGen
  79 ////
  80
  81 enum BiomeGenType {
  82         BIOMEGEN_ORIGINAL,
  83 };
  84
  85 struct BiomeParams {
  86         virtual void readParams(const Settings *settings) = 0;
  87         virtual void writeParams(Settings *settings) const = 0;
  88         virtual ~BiomeParams() = default;
  89
  90         s32 seed;
  91 };
  92
  93 // WARNING: this class is not thread-safe
  94 class BiomeGen {
  95 public:
  96         virtual ~BiomeGen() = default;
  97
  98         virtual BiomeGenType getType() const = 0;
  99
 100         // Clone this BiomeGen and set a the new BiomeManager to be used by the copy
 101         virtual BiomeGen *clone(BiomeManager *biomemgr) const = 0;
 102
 103         // Check that the internal chunk size is what the mapgen expects, just to be sure.
 104         inline void assertChunkSize(v3s16 expect) const
 105         {
 106                 FATAL_ERROR_IF(m_csize != expect, "Chunk size mismatches");
 107         }
 108
 109         // Calculates the biome at the exact position provided.  This function can
 110         // be called at any time, but may be less efficient than the latter methods,
 111         // depending on implementation.
 112         virtual Biome *calcBiomeAtPoint(v3s16 pos) const = 0;
 113
 114         // Computes any intermediate results needed for biome generation.  Must be
 115         // called before using any of: getBiomes, getBiomeAtPoint, or getBiomeAtIndex.
 116         // Calling this invalidates the previous results stored in biomemap.
 117         virtual void calcBiomeNoise(v3s16 pmin) = 0;
 118
 119         // Gets all biomes in current chunk using each corresponding element of
 120         // heightmap as the y position, then stores the results by biome index in
 121         // biomemap (also returned)
 122         virtual biome_t *getBiomes(s16 *heightmap, v3s16 pmin) = 0;
 123
 124         // Gets a single biome at the specified position, which must be contained
 125         // in the region formed by m_pmin and (m_pmin + m_csize - 1).
 126         virtual Biome *getBiomeAtPoint(v3s16 pos) const = 0;
 127
 128         // Same as above, but uses a raw numeric index correlating to the (x,z) position.
 129         virtual Biome *getBiomeAtIndex(size_t index, v3s16 pos) const = 0;
 130
 131         // Result of calcBiomes bulk computation.
 132         biome_t *biomemap = nullptr;
 133
 134 protected:
 135         BiomeManager *m_bmgr = nullptr;
 136         v3s16 m_pmin;
 137         v3s16 m_csize;
 138 };
 139
 140
 141 ////
 142 //// BiomeGen implementations
 143 ////
 144
 145 //
 146 // Original biome algorithm (Whittaker's classification + surface height)
 147 //
 148
 149 struct BiomeParamsOriginal : public BiomeParams {
 150         BiomeParamsOriginal() :
 151                 np_heat(50, 50, v3f(1000.0, 1000.0, 1000.0), 5349, 3, 0.5, 2.0),
 152                 np_humidity(50, 50, v3f(1000.0, 1000.0, 1000.0), 842, 3, 0.5, 2.0),
 153                 np_heat_blend(0, 1.5, v3f(8.0, 8.0, 8.0), 13, 2, 1.0, 2.0),
 154                 np_humidity_blend(0, 1.5, v3f(8.0, 8.0, 8.0), 90003, 2, 1.0, 2.0)
 155         {
 156         }
 157
 158         virtual void readParams(const Settings *settings);
 159         virtual void writeParams(Settings *settings) const;
 160
 161         NoiseParams np_heat;
 162         NoiseParams np_humidity;
 163         NoiseParams np_heat_blend;
 164         NoiseParams np_humidity_blend;
 165 };
 166
 167 class BiomeGenOriginal : public BiomeGen {
 168 public:
 169         BiomeGenOriginal(BiomeManager *biomemgr,
 170                 const BiomeParamsOriginal *params, v3s16 chunksize);
 171         virtual ~BiomeGenOriginal();
 172
 173         BiomeGenType getType() const { return BIOMEGEN_ORIGINAL; }
 174
 175         BiomeGen *clone(BiomeManager *biomemgr) const;
 176
 177         // Slower, meant for Script API use
 178         float calcHeatAtPoint(v3s16 pos) const;
 179         float calcHumidityAtPoint(v3s16 pos) const;
 180         Biome *calcBiomeAtPoint(v3s16 pos) const;
 181
 182         void calcBiomeNoise(v3s16 pmin);
 183
 184         biome_t *getBiomes(s16 *heightmap, v3s16 pmin);
 185         Biome *getBiomeAtPoint(v3s16 pos) const;
 186         Biome *getBiomeAtIndex(size_t index, v3s16 pos) const;
 187
 188         Biome *calcBiomeFromNoise(float heat, float humidity, v3s16 pos) const;
 189
 190         float *heatmap;
 191         float *humidmap;
 192
 193 private:
 194         const BiomeParamsOriginal *m_params;
 195
 196         Noise *noise_heat;
 197         Noise *noise_humidity;
 198         Noise *noise_heat_blend;
 199         Noise *noise_humidity_blend;
 200 };
 201
 202
 203 ////
 204 //// BiomeManager
 205 ////
 206
 207 class BiomeManager : public ObjDefManager {
 208 public:
 209         BiomeManager(Server *server);
 210         virtual ~BiomeManager() = default;
 211
 212         BiomeManager *clone() const;
 213
 214         const char *getObjectTitle() const
 215         {
 216                 return "biome";
 217         }
 218
 219         static Biome *create(BiomeType type)
 220         {
 221                 return new Biome;
 222         }
 223
 224         BiomeGen *createBiomeGen(BiomeGenType type, BiomeParams *params, v3s16 chunksize)
 225         {
 226                 switch (type) {
 227                 case BIOMEGEN_ORIGINAL:
 228                         return new BiomeGenOriginal(this,
 229                                 (BiomeParamsOriginal *)params, chunksize);
 230                 default:
 231                         return NULL;
 232                 }
 233         }
 234
 235         static BiomeParams *createBiomeParams(BiomeGenType type)
 236         {
 237                 switch (type) {
 238                 case BIOMEGEN_ORIGINAL:
 239                         return new BiomeParamsOriginal;
 240                 default:
 241                         return NULL;
 242                 }
 243         }
 244
 245         virtual void clear();
 246
 247 private:
 248         BiomeManager() {};
 249
 250         Server *m_server;
 251
 252 };