src/nodedef.h

   1 /*
   2 Minetest-m13
   3 Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 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 General Public License for more details.
  14
  15 You should have received a copy of the GNU 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 NODEDEF_HEADER
  21 #define NODEDEF_HEADER
  22
  23 #include "common_irrlicht.h"
  24 #include <string>
  25 #include <iostream>
  26 #include <set>
  27 #include "mapnode.h"
  28 #ifndef SERVER
  29 #include "tile.h"
  30 #endif
  31 #include "materials.h" // MaterialProperties
  32 class IItemDefManager;
  33 class ITextureSource;
  34 class IGameDef;
  35
  36 enum ContentParamType
  37 {
  38         CPT_NONE,
  39         CPT_LIGHT,
  40 };
  41
  42 enum ContentParamType2
  43 {
  44         CPT2_NONE,
  45         // Need 8-bit param2
  46         CPT2_FULL,
  47         // Flowing liquid properties
  48         CPT2_FLOWINGLIQUID,
  49         // Direction for chests and furnaces and such
  50         CPT2_FACEDIR,
  51         // Direction for signs, torches and such
  52         CPT2_WALLMOUNTED,
  53 };
  54
  55 enum LiquidType
  56 {
  57         LIQUID_NONE,
  58         LIQUID_FLOWING,
  59         LIQUID_SOURCE
  60 };
  61
  62 enum NodeBoxType
  63 {
  64         NODEBOX_REGULAR, // Regular block; allows buildable_to
  65         NODEBOX_FIXED, // Static separately defined box
  66         NODEBOX_WALLMOUNTED, // Box for wall mounted nodes; (top, bottom, side)
  67 };
  68
  69 struct NodeBox
  70 {
  71         enum NodeBoxType type;
  72         // NODEBOX_REGULAR (no parameters)
  73         // NODEBOX_FIXED
  74         core::aabbox3d<f32> fixed;
  75         // NODEBOX_WALLMOUNTED
  76         core::aabbox3d<f32> wall_top;
  77         core::aabbox3d<f32> wall_bottom;
  78         core::aabbox3d<f32> wall_side; // being at the -X side
  79
  80         NodeBox():
  81                 type(NODEBOX_REGULAR),
  82                 // default is rail-like
  83                 fixed(-BS/2, -BS/2, -BS/2, BS/2, -BS/2+BS/16., BS/2),
  84                 // default is sign/ladder-like
  85                 wall_top(-BS/2, BS/2-BS/16., -BS/2, BS/2, BS/2, BS/2),
  86                 wall_bottom(-BS/2, -BS/2, -BS/2, BS/2, -BS/2+BS/16., BS/2),
  87                 wall_side(-BS/2, -BS/2, -BS/2, -BS/2+BS/16., BS/2, BS/2)
  88         {}
  89
  90         void serialize(std::ostream &os) const;
  91         void deSerialize(std::istream &is);
  92 };
  93
  94 struct MapNode;
  95 class NodeMetadata;
  96
  97 struct MaterialSpec
  98 {
  99         std::string tname;
 100         bool backface_culling;
 101
 102         MaterialSpec(const std::string &tname_="", bool backface_culling_=true):
 103                 tname(tname_),
 104                 backface_culling(backface_culling_)
 105         {}
 106
 107         void serialize(std::ostream &os) const;
 108         void deSerialize(std::istream &is);
 109 };
 110
 111 enum NodeDrawType
 112 {
 113         NDT_NORMAL, // A basic solid block
 114         NDT_AIRLIKE, // Nothing is drawn
 115         NDT_LIQUID, // Do not draw face towards same kind of flowing/source liquid
 116         NDT_FLOWINGLIQUID, // A very special kind of thing
 117         NDT_GLASSLIKE, // Glass-like, don't draw faces towards other glass
 118         NDT_ALLFACES, // Leaves-like, draw all faces no matter what
 119         NDT_ALLFACES_OPTIONAL, // Fancy -> allfaces, fast -> normal
 120         NDT_TORCHLIKE,
 121         NDT_SIGNLIKE,
 122         NDT_PLANTLIKE,
 123         NDT_FENCELIKE,
 124         NDT_RAILLIKE,
 125 };
 126
 127 #define CF_SPECIAL_COUNT 2
 128
 129 struct ContentFeatures
 130 {
 131         /*
 132                 Cached stuff
 133         */
 134 #ifndef SERVER
 135         // 0     1     2     3     4     5
 136         // up    down  right left  back  front
 137         TileSpec tiles[6];
 138         // Special material/texture
 139         // - Currently used for flowing liquids
 140         video::SMaterial *special_materials[CF_SPECIAL_COUNT];
 141         AtlasPointer *special_aps[CF_SPECIAL_COUNT];
 142         u8 solidness; // Used when choosing which face is drawn
 143         u8 visual_solidness; // When solidness=0, this tells how it looks like
 144         bool backface_culling;
 145 #endif
 146
 147         /*
 148                 Actual data
 149         */
 150
 151         std::string name; // "" = undefined node
 152
 153         // Visual definition
 154         enum NodeDrawType drawtype;
 155         float visual_scale; // Misc. scale parameter
 156         std::string tname_tiles[6];
 157         MaterialSpec mspec_special[CF_SPECIAL_COUNT]; // Use setter methods
 158         u8 alpha;
 159
 160         // Post effect color, drawn when the camera is inside the node.
 161         video::SColor post_effect_color;
 162         // Type of MapNode::param1
 163         ContentParamType param_type;
 164         // Type of MapNode::param2
 165         ContentParamType2 param_type_2;
 166         // True for all ground-like things like stone and mud, false for eg. trees
 167         bool is_ground_content;
 168         bool light_propagates;
 169         bool sunlight_propagates;
 170         // This is used for collision detection.
 171         // Also for general solidness queries.
 172         bool walkable;
 173         // Player can point to these
 174         bool pointable;
 175         // Player can dig these
 176         bool diggable;
 177         // Player can climb these
 178         bool climbable;
 179         // Player can build on these
 180         bool buildable_to;
 181         // Metadata name of node (eg. "furnace")
 182         std::string metadata_name;
 183         // Whether the node is non-liquid, source liquid or flowing liquid
 184         enum LiquidType liquid_type;
 185         // If the content is liquid, this is the flowing version of the liquid.
 186         std::string liquid_alternative_flowing;
 187         // If the content is liquid, this is the source version of the liquid.
 188         std::string liquid_alternative_source;
 189         // Viscosity for fluid flow, ranging from 1 to 7, with
 190         // 1 giving almost instantaneous propagation and 7 being
 191         // the slowest possible
 192         u8 liquid_viscosity;
 193         // Amount of light the node emits
 194         u8 light_source;
 195         u32 damage_per_second;
 196         NodeBox selection_box;
 197         MaterialProperties material;
 198         // Compatibility with old maps
 199         // Set to true if paramtype used to be 'facedir_simple'
 200         bool legacy_facedir_simple;
 201         // Set to true if wall_mounted used to be set to true
 202         bool legacy_wallmounted;
 203
 204         /*
 205                 Methods
 206         */
 207
 208         ContentFeatures();
 209         ~ContentFeatures();
 210         void reset();
 211         void serialize(std::ostream &os);
 212         void deSerialize(std::istream &is);
 213
 214         /*
 215                 Some handy methods
 216         */
 217         bool isLiquid() const{
 218                 return (liquid_type != LIQUID_NONE);
 219         }
 220         bool sameLiquid(const ContentFeatures &f) const{
 221                 if(!isLiquid() || !f.isLiquid()) return false;
 222                 return (liquid_alternative_flowing == f.liquid_alternative_flowing);
 223         }
 224 };
 225
 226 class INodeDefManager
 227 {
 228 public:
 229         INodeDefManager(){}
 230         virtual ~INodeDefManager(){}
 231         // Get node definition
 232         virtual const ContentFeatures& get(content_t c) const=0;
 233         virtual const ContentFeatures& get(const MapNode &n) const=0;
 234         virtual bool getId(const std::string &name, content_t &result) const=0;
 235         virtual content_t getId(const std::string &name) const=0;
 236         virtual const ContentFeatures& get(const std::string &name) const=0;
 237
 238         virtual void serialize(std::ostream &os)=0;
 239 };
 240
 241 class IWritableNodeDefManager : public INodeDefManager
 242 {
 243 public:
 244         IWritableNodeDefManager(){}
 245         virtual ~IWritableNodeDefManager(){}
 246         virtual IWritableNodeDefManager* clone()=0;
 247         // Get node definition
 248         virtual const ContentFeatures& get(content_t c) const=0;
 249         virtual const ContentFeatures& get(const MapNode &n) const=0;
 250         virtual bool getId(const std::string &name, content_t &result) const=0;
 251         virtual content_t getId(const std::string &name) const=0;
 252         // If not found, returns the features of CONTENT_IGNORE
 253         virtual const ContentFeatures& get(const std::string &name) const=0;
 254
 255         // Register node definition
 256         virtual void set(content_t c, const ContentFeatures &def)=0;
 257         // Register node definition by name (allocate an id)
 258         // If returns CONTENT_IGNORE, could not allocate id
 259         virtual content_t set(const std::string &name,
 260                         const ContentFeatures &def)=0;
 261         // If returns CONTENT_IGNORE, could not allocate id
 262         virtual content_t allocateDummy(const std::string &name)=0;
 263
 264         /*
 265                 Update item alias mapping.
 266                 Call after updating item definitions.
 267         */
 268         virtual void updateAliases(IItemDefManager *idef)=0;
 269
 270         /*
 271                 Update tile textures to latest return values of TextueSource.
 272                 Call after updating the texture atlas of a TextureSource.
 273         */
 274         virtual void updateTextures(ITextureSource *tsrc)=0;
 275
 276         virtual void serialize(std::ostream &os)=0;
 277         virtual void deSerialize(std::istream &is)=0;
 278 };
 279
 280 IWritableNodeDefManager* createNodeDefManager();
 281
 282 #endif
 283