src/emerge.h

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #ifndef EMERGE_HEADER
  21 #define EMERGE_HEADER
  22
  23 #include <map>
  24 #include <queue>
  25 #include "util/thread.h"
  26
  27 #define BLOCK_EMERGE_ALLOWGEN (1<<0)
  28
  29 #define EMERGE_DBG_OUT(x) \
  30         { if (enable_mapgen_debug_info) \
  31         infostream << "EmergeThread: " x << std::endl; }
  32
  33 class Mapgen;
  34 struct MapgenParams;
  35 struct MapgenFactory;
  36 class Biome;
  37 class BiomeDefManager;
  38 class EmergeThread;
  39 class ManualMapVoxelManipulator;
  40
  41 #include "server.h"
  42
  43 struct BlockMakeData {
  44         ManualMapVoxelManipulator *vmanip;
  45         u64 seed;
  46         v3s16 blockpos_min;
  47         v3s16 blockpos_max;
  48         v3s16 blockpos_requested;
  49         UniqueQueue<v3s16> transforming_liquid;
  50         INodeDefManager *nodedef;
  51
  52         BlockMakeData():
  53                 vmanip(NULL),
  54                 seed(0),
  55                 nodedef(NULL)
  56         {}
  57
  58         ~BlockMakeData() { delete vmanip; }
  59 };
  60
  61 struct BlockEmergeData {
  62         u16 peer_requested;
  63         u8 flags;
  64 };
  65
  66 class EmergeManager {
  67 public:
  68         INodeDefManager *ndef;
  69
  70         std::map<std::string, MapgenFactory *> mglist;
  71
  72         std::vector<Mapgen *> mapgen;
  73         std::vector<EmergeThread *> emergethread;
  74
  75         //settings
  76         MapgenParams *params;
  77         bool mapgen_debug_info;
  78         u16 qlimit_total;
  79         u16 qlimit_diskonly;
  80         u16 qlimit_generate;
  81
  82         //block emerge queue data structures
  83         JMutex queuemutex;
  84         std::map<v3s16, BlockEmergeData *> blocks_enqueued;
  85         std::map<u16, u16> peer_queue_count;
  86
  87         //Mapgen-related structures
  88         BiomeDefManager *biomedef;
  89         std::vector<Ore *> ores;
  90         std::vector<Decoration *> decorations;
  91
  92         EmergeManager(IGameDef *gamedef);
  93         ~EmergeManager();
  94
  95         void initMapgens(MapgenParams *mgparams);
  96         Mapgen *createMapgen(std::string mgname, int mgid,
  97                                                 MapgenParams *mgparams);
  98         MapgenParams *createMapgenParams(std::string mgname);
  99         bool enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate);
 100
 101         void registerMapgen(std::string name, MapgenFactory *mgfactory);
 102         MapgenParams *getParamsFromSettings(Settings *settings);
 103         void setParamsToSettings(Settings *settings);
 104
 105         //mapgen helper methods
 106         Biome *getBiomeAtPoint(v3s16 p);
 107         int getGroundLevelAtPoint(v2s16 p);
 108         bool isBlockUnderground(v3s16 blockpos);
 109         u32 getBlockSeed(v3s16 p);
 110 };
 111
 112 class EmergeThread : public SimpleThread
 113 {
 114         Server *m_server;
 115         ServerMap *map;
 116         EmergeManager *emerge;
 117         Mapgen *mapgen;
 118         bool enable_mapgen_debug_info;
 119         int id;
 120
 121 public:
 122         Event qevent;
 123         std::queue<v3s16> blockqueue;
 124
 125         EmergeThread(Server *server, int ethreadid):
 126                 SimpleThread(),
 127                 m_server(server),
 128                 map(NULL),
 129                 emerge(NULL),
 130                 mapgen(NULL),
 131                 id(ethreadid)
 132         {
 133         }
 134
 135         void *Thread();
 136
 137         void trigger()
 138         {
 139                 setRun(true);
 140                 if(IsRunning() == false)
 141                 {
 142                         Start();
 143                 }
 144         }
 145
 146         bool popBlockEmerge(v3s16 *pos, u8 *flags);
 147         bool getBlockOrStartGen(v3s16 p, MapBlock **b,
 148                                                         BlockMakeData *data, bool allow_generate);
 149 };
 150
 151 #endif