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 *getCurrentMapgen();
  97         Mapgen *createMapgen(std::string mgname, int mgid,
  98                                                 MapgenParams *mgparams);
  99         MapgenParams *createMapgenParams(std::string mgname);
 100         bool enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate);
 101
 102         void registerMapgen(std::string name, MapgenFactory *mgfactory);
 103         MapgenParams *getParamsFromSettings(Settings *settings);
 104         void setParamsToSettings(Settings *settings);
 105
 106         //mapgen helper methods
 107         Biome *getBiomeAtPoint(v3s16 p);
 108         int getGroundLevelAtPoint(v2s16 p);
 109         bool isBlockUnderground(v3s16 blockpos);
 110         u32 getBlockSeed(v3s16 p);
 111 };
 112
 113 class EmergeThread : public SimpleThread
 114 {
 115 public:
 116         Server *m_server;
 117         ServerMap *map;
 118         EmergeManager *emerge;
 119         Mapgen *mapgen;
 120         bool enable_mapgen_debug_info;
 121         int id;
 122
 123         Event qevent;
 124         std::queue<v3s16> blockqueue;
 125
 126         EmergeThread(Server *server, int ethreadid):
 127                 SimpleThread(),
 128                 m_server(server),
 129                 map(NULL),
 130                 emerge(NULL),
 131                 mapgen(NULL),
 132                 id(ethreadid)
 133         {
 134         }
 135
 136         void *Thread();
 137
 138         void trigger()
 139         {
 140                 setRun(true);
 141                 if(IsRunning() == false)
 142                 {
 143                         Start();
 144                 }
 145         }
 146
 147         bool popBlockEmerge(v3s16 *pos, u8 *flags);
 148         bool getBlockOrStartGen(v3s16 p, MapBlock **b,
 149                                                         BlockMakeData *data, bool allow_generate);
 150 };
 151
 152 #endif