3 Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
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.
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.
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.
20 #ifndef MAPNODE_HEADER
21 #define MAPNODE_HEADER
24 #include "common_irrlicht.h"
27 #include "exceptions.h"
28 #include "serialization.h"
30 #include "materials.h"
34 - Material = irrlicht's Material class
35 - Content = (content_t) content of a node
36 - Tile = TileSpec at some side of a node of some content type
39 0x000...0x07f: param2 is fully usable
40 0x800...0xfff: param2 lower 4 bytes are free
42 typedef u16 content_t;
43 #define MAX_CONTENT 0xfff
46 Initializes all kind of stuff in here.
47 Many things depend on this.
49 This accesses g_texturesource; if it is non-NULL, textures are set.
51 Client first calls this with g_texturesource=NULL to run some
52 unit tests and stuff, then it runs this again with g_texturesource
53 defined to get the textures.
55 Server only calls this once with g_texturesource=NULL.
62 Anything that stores MapNodes doesn't have to preserve parameters
63 associated with this material.
65 Doesn't create faces with anything and is considered being
66 out-of-map in the game map.
68 //#define CONTENT_IGNORE 255
69 #define CONTENT_IGNORE 127
70 #define CONTENT_IGNORE_DEFAULT_PARAM 0
73 The common material through which the player can walk and which
74 is transparent to light
76 //#define CONTENT_AIR 254
77 #define CONTENT_AIR 126
88 // Direction for chests and furnaces and such
102 struct ContentFeatures
104 // Type of MapNode::param1
105 ContentParamType param_type;
117 video::ITexture *inventory_texture;
119 // True for all ground-like things like stone and mud, false for eg. trees
120 bool is_ground_content;
121 bool light_propagates;
122 bool sunlight_propagates;
123 u8 solidness; // Used when choosing which face is drawn
124 u8 visual_solidness; // When solidness=0, this tells how it looks like
125 // This is used for collision detection.
126 // Also for general solidness queries.
128 // Player can point to these
130 // Player can dig these
132 // Player can climb these
134 // Player can build on these
136 // Whether the node has no liquid, source liquid or flowing liquid
137 enum LiquidType liquid_type;
138 // If true, param2 is set to direction when placed. Used for torches.
139 // NOTE: the direction format is quite inefficient and should be changed
141 // If true, node is equivalent to air. Torches are, air is. Water is not.
142 // Is used for example to check whether a mud block can have grass on.
145 // Inventory item string as which the node appears in inventory when dug.
146 // Mineral overrides this.
147 std::string dug_item;
149 // Extra dug item and its rarity
150 std::string extra_dug_item;
151 s32 extra_dug_item_rarity;
153 // Initial metadata is cloned from this
154 NodeMetadata *initial_metadata;
156 // If the content is liquid, this is the flowing version of the liquid.
157 // If content is liquid, this is the same content.
158 content_t liquid_alternative_flowing;
159 // If the content is liquid, this is the source version of the liquid.
160 content_t liquid_alternative_source;
161 // Viscosity for fluid flow, ranging from 1 to 7, with
162 // 1 giving almost instantaneous propagation and 7 being
163 // the slowest possible
165 // Used currently for flowing liquids
167 // Post effect color, drawn when the camera is inside the node.
168 video::SColor post_effect_color;
169 // Special irrlicht material, used sometimes
170 video::SMaterial *special_material;
171 AtlasPointer *special_atlas;
173 // Amount of light the node emits
176 // Digging properties for different tools
177 DiggingPropertiesList digging_properties;
179 u32 damage_per_second;
181 // NOTE: Move relevant properties to here from elsewhere
185 param_type = CPT_NONE;
186 inventory_texture = NULL;
187 is_ground_content = false;
188 light_propagates = false;
189 sunlight_propagates = false;
191 visual_solidness = 0;
196 buildable_to = false;
197 liquid_type = LIQUID_NONE;
198 wall_mounted = false;
199 air_equivalent = false;
201 initial_metadata = NULL;
202 liquid_alternative_flowing = CONTENT_IGNORE;
203 liquid_alternative_source = CONTENT_IGNORE;
204 liquid_viscosity = 0;
206 post_effect_color = video::SColor(0, 0, 0, 0);
207 special_material = NULL;
208 special_atlas = NULL;
210 digging_properties.clear();
211 damage_per_second = 0;
222 Quickhands for simple materials
225 void setTexture(u16 i, std::string name, u8 alpha=255);
227 void setAllTextures(std::string name, u8 alpha=255)
229 for(u16 i=0; i<6; i++)
231 setTexture(i, name, alpha);
233 // Force inventory texture too
234 setInventoryTexture(name);
237 void setTile(u16 i, const TileSpec &tile)
241 void setAllTiles(const TileSpec &tile)
243 for(u16 i=0; i<6; i++)
249 void setInventoryTexture(std::string imgname);
251 void setInventoryTextureCube(std::string top,
252 std::string left, std::string right);
256 Call this to access the ContentFeature list
258 ContentFeatures & content_features(content_t i);
259 ContentFeatures & content_features(MapNode &n);
262 Here is a bunch of DEPRECATED functions.
266 If true, the material allows light propagation and brightness is stored
268 NOTE: Don't use, use "content_features(m).whatever" instead
270 inline bool light_propagates_content(content_t m)
272 return content_features(m).light_propagates;
275 If true, the material allows lossless sunlight propagation.
276 NOTE: It doesn't seem to go through torches regardlessly of this
277 NOTE: Don't use, use "content_features(m).whatever" instead
279 inline bool sunlight_propagates_content(content_t m)
281 return content_features(m).sunlight_propagates;
284 On a node-node surface, the material of the node with higher solidness
289 NOTE: Don't use, use "content_features(m).whatever" instead
291 inline u8 content_solidness(content_t m)
293 return content_features(m).solidness;
295 // Objects collide with walkable contents
296 // NOTE: Don't use, use "content_features(m).whatever" instead
297 inline bool content_walkable(content_t m)
299 return content_features(m).walkable;
301 // NOTE: Don't use, use "content_features(m).whatever" instead
302 inline bool content_liquid(content_t m)
304 return content_features(m).liquid_type != LIQUID_NONE;
306 // NOTE: Don't use, use "content_features(m).whatever" instead
307 inline bool content_flowing_liquid(content_t m)
309 return content_features(m).liquid_type == LIQUID_FLOWING;
311 // NOTE: Don't use, use "content_features(m).whatever" instead
312 inline bool content_liquid_source(content_t m)
314 return content_features(m).liquid_type == LIQUID_SOURCE;
316 // CONTENT_WATER || CONTENT_WATERSOURCE -> CONTENT_WATER
317 // CONTENT_LAVA || CONTENT_LAVASOURCE -> CONTENT_LAVA
318 // NOTE: Don't use, use "content_features(m).whatever" instead
319 inline content_t make_liquid_flowing(content_t m)
321 u8 c = content_features(m).liquid_alternative_flowing;
322 assert(c != CONTENT_IGNORE);
325 // Pointable contents can be pointed to in the map
326 // NOTE: Don't use, use "content_features(m).whatever" instead
327 inline bool content_pointable(content_t m)
329 return content_features(m).pointable;
331 // NOTE: Don't use, use "content_features(m).whatever" instead
332 inline bool content_diggable(content_t m)
334 return content_features(m).diggable;
336 // NOTE: Don't use, use "content_features(m).whatever" instead
337 inline bool content_buildable_to(content_t m)
339 return content_features(m).buildable_to;
343 Nodes make a face if contents differ and solidness differs.
346 1: Face uses m1's content
347 2: Face uses m2's content
349 inline u8 face_contents(content_t m1, content_t m2)
351 if(m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE)
354 bool contents_differ = (m1 != m2);
356 // Contents don't differ for different forms of same liquid
357 if(content_liquid(m1) && content_liquid(m2)
358 && make_liquid_flowing(m1) == make_liquid_flowing(m2))
359 contents_differ = false;
361 bool solidness_differs = (content_solidness(m1) != content_solidness(m2));
362 bool makes_face = contents_differ && solidness_differs;
364 if(makes_face == false)
367 if(content_solidness(m1) > content_solidness(m2))
374 Packs directions like (1,0,0), (1,-1,0)
376 inline u8 packDir(v3s16 dir)
397 inline v3s16 unpackDir(u8 b)
420 facedir: CPT_FACEDIR_SIMPLE param1 value
421 dir: The face for which stuff is wanted
422 return value: The face from which the stuff is actually found
424 NOTE: Currently this uses 2 bits for Z-,X-,Z+,X+, should there be Y+
427 v3s16 facedir_rotate(u8 facedir, v3s16 dir);
436 Masks for MapNode.param2 of flowing liquids
438 #define LIQUID_LEVEL_MASK 0x07
439 #define LIQUID_FLOW_DOWN_MASK 0x08
441 /* maximum amount of liquid in a block */
442 #define LIQUID_LEVEL_MAX LIQUID_LEVEL_MASK
443 #define LIQUID_LEVEL_SOURCE (LIQUID_LEVEL_MAX+1)
446 This is the stuff what the whole world consists of.
454 0x00-0x7f: Short content type
455 0x80-0xff: Long content type (param2>>4 makes up low bytes)
464 Misc parameter. Initialized to 0.
465 - For light_propagates() blocks, this is light intensity,
466 stored logarithmically from 0 to LIGHT_MAX.
467 Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
468 - Contains 2 values, day- and night lighting. Each takes 4 bits.
469 - Mineral content (should be removed from here)
470 - Uhh... well, most blocks have light or nothing in here.
479 The second parameter. Initialized to 0.
480 E.g. direction for torches and flowing water.
481 If param0 >= 0x80, bits 0xf0 of this is extended content type data
489 MapNode(const MapNode & n)
494 MapNode(content_t content=CONTENT_AIR, u8 a_param1=0, u8 a_param2=0)
499 // Set after other params because this needs to override part of param2
503 bool operator==(const MapNode &other)
505 return (param0 == other.param0
506 && param1 == other.param1
507 && param2 == other.param2);
510 // To be used everywhere
511 content_t getContent()
516 return (param0<<4) + (param2>>4);
518 void setContent(content_t c)
530 param2 |= (c&0x0f)<<4;
535 These four are DEPRECATED I guess. -c55
537 bool light_propagates()
539 return light_propagates_content(getContent());
541 bool sunlight_propagates()
543 return sunlight_propagates_content(getContent());
547 return content_solidness(getContent());
551 return content_features(*this).light_source;
554 u8 getLightBanksWithSource()
556 // Select the brightest of [light source, propagated light]
559 if(content_features(*this).param_type == CPT_LIGHT)
561 lightday = param1 & 0x0f;
562 lightnight = (param1>>4)&0x0f;
564 if(light_source() > lightday)
565 lightday = light_source();
566 if(light_source() > lightnight)
567 lightnight = light_source();
568 return (lightday&0x0f) | ((lightnight<<4)&0xf0);
571 u8 getLight(enum LightBank bank)
573 // Select the brightest of [light source, propagated light]
575 if(content_features(*this).param_type == CPT_LIGHT)
577 if(bank == LIGHTBANK_DAY)
578 light = param1 & 0x0f;
579 else if(bank == LIGHTBANK_NIGHT)
580 light = (param1>>4)&0x0f;
584 if(light_source() > light)
585 light = light_source();
589 // 0 <= daylight_factor <= 1000
590 // 0 <= return value <= LIGHT_SUN
591 u8 getLightBlend(u32 daylight_factor)
593 u8 l = ((daylight_factor * getLight(LIGHTBANK_DAY)
594 + (1000-daylight_factor) * getLight(LIGHTBANK_NIGHT))
597 if(getLight(LIGHTBANK_DAY) == LIGHT_SUN)
603 /*// 0 <= daylight_factor <= 1000
604 // 0 <= return value <= 255
605 u8 getLightBlend(u32 daylight_factor)
607 u8 daylight = decode_light(getLight(LIGHTBANK_DAY));
608 u8 nightlight = decode_light(getLight(LIGHTBANK_NIGHT));
609 u8 mix = ((daylight_factor * daylight
610 + (1000-daylight_factor) * nightlight)
615 void setLight(enum LightBank bank, u8 a_light)
617 // If node doesn't contain light data, ignore this
618 if(content_features(*this).param_type != CPT_LIGHT)
620 if(bank == LIGHTBANK_DAY)
623 param1 |= a_light & 0x0f;
625 else if(bank == LIGHTBANK_NIGHT)
628 param1 |= (a_light & 0x0f)<<4;
636 Get tile of a face of the node.
637 dir: direction of face
638 Returns: TileSpec. Can contain miscellaneous texture coordinates,
639 which must be obeyed so that the texture atlas can be used.
641 TileSpec getTile(v3s16 dir);
644 Gets mineral content of node, if there is any.
645 MINERAL_NONE if doesn't contain or isn't able to contain mineral.
650 Serialization functions
653 static u32 serializedLength(u8 version);
654 void serialize(u8 *dest, u8 version);
655 void deSerialize(u8 *source, u8 version);
660 Gets lighting value at face of node
662 Parameters must consist of air and !air.
663 Order doesn't matter.
665 If either of the nodes doesn't exist, light is 0.
668 daynight_ratio: 0...1000
670 n2: getNodeParent(p + face_dir)
671 face_dir: axis oriented unit vector from p to p2
673 returns encoded light value.
675 u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,