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 // Initial metadata is cloned from this
150 NodeMetadata *initial_metadata;
152 // If the content is liquid, this is the flowing version of the liquid.
153 // If content is liquid, this is the same content.
154 content_t liquid_alternative_flowing;
155 // If the content is liquid, this is the source version of the liquid.
156 content_t liquid_alternative_source;
157 // Viscosity for fluid flow, ranging from 1 to 7, with
158 // 1 giving almost instantaneous propagation and 7 being
159 // the slowest possible
161 // Used currently for flowing liquids
163 // Special irrlicht material, used sometimes
164 video::SMaterial *special_material;
165 AtlasPointer *special_atlas;
167 // Amount of light the node emits
170 // Digging properties for different tools
171 DiggingPropertiesList digging_properties;
173 u32 damage_per_second;
175 // NOTE: Move relevant properties to here from elsewhere
179 param_type = CPT_NONE;
180 inventory_texture = NULL;
181 is_ground_content = false;
182 light_propagates = false;
183 sunlight_propagates = false;
185 visual_solidness = 0;
190 buildable_to = false;
191 liquid_type = LIQUID_NONE;
192 wall_mounted = false;
193 air_equivalent = false;
195 initial_metadata = NULL;
196 liquid_alternative_flowing = CONTENT_IGNORE;
197 liquid_alternative_source = CONTENT_IGNORE;
198 liquid_viscosity = 0;
200 special_material = NULL;
201 special_atlas = NULL;
203 digging_properties.clear();
204 damage_per_second = 0;
215 Quickhands for simple materials
218 void setTexture(u16 i, std::string name, u8 alpha=255);
220 void setAllTextures(std::string name, u8 alpha=255)
222 for(u16 i=0; i<6; i++)
224 setTexture(i, name, alpha);
226 // Force inventory texture too
227 setInventoryTexture(name);
230 void setTile(u16 i, const TileSpec &tile)
234 void setAllTiles(const TileSpec &tile)
236 for(u16 i=0; i<6; i++)
242 void setInventoryTexture(std::string imgname);
244 void setInventoryTextureCube(std::string top,
245 std::string left, std::string right);
249 Call this to access the ContentFeature list
251 ContentFeatures & content_features(content_t i);
252 ContentFeatures & content_features(MapNode &n);
255 Here is a bunch of DEPRECATED functions.
259 If true, the material allows light propagation and brightness is stored
261 NOTE: Don't use, use "content_features(m).whatever" instead
263 inline bool light_propagates_content(content_t m)
265 return content_features(m).light_propagates;
268 If true, the material allows lossless sunlight propagation.
269 NOTE: It doesn't seem to go through torches regardlessly of this
270 NOTE: Don't use, use "content_features(m).whatever" instead
272 inline bool sunlight_propagates_content(content_t m)
274 return content_features(m).sunlight_propagates;
277 On a node-node surface, the material of the node with higher solidness
282 NOTE: Don't use, use "content_features(m).whatever" instead
284 inline u8 content_solidness(content_t m)
286 return content_features(m).solidness;
288 // Objects collide with walkable contents
289 // NOTE: Don't use, use "content_features(m).whatever" instead
290 inline bool content_walkable(content_t m)
292 return content_features(m).walkable;
294 // NOTE: Don't use, use "content_features(m).whatever" instead
295 inline bool content_liquid(content_t m)
297 return content_features(m).liquid_type != LIQUID_NONE;
299 // NOTE: Don't use, use "content_features(m).whatever" instead
300 inline bool content_flowing_liquid(content_t m)
302 return content_features(m).liquid_type == LIQUID_FLOWING;
304 // NOTE: Don't use, use "content_features(m).whatever" instead
305 inline bool content_liquid_source(content_t m)
307 return content_features(m).liquid_type == LIQUID_SOURCE;
309 // CONTENT_WATER || CONTENT_WATERSOURCE -> CONTENT_WATER
310 // CONTENT_LAVA || CONTENT_LAVASOURCE -> CONTENT_LAVA
311 // NOTE: Don't use, use "content_features(m).whatever" instead
312 inline content_t make_liquid_flowing(content_t m)
314 u8 c = content_features(m).liquid_alternative_flowing;
315 assert(c != CONTENT_IGNORE);
318 // Pointable contents can be pointed to in the map
319 // NOTE: Don't use, use "content_features(m).whatever" instead
320 inline bool content_pointable(content_t m)
322 return content_features(m).pointable;
324 // NOTE: Don't use, use "content_features(m).whatever" instead
325 inline bool content_diggable(content_t m)
327 return content_features(m).diggable;
329 // NOTE: Don't use, use "content_features(m).whatever" instead
330 inline bool content_buildable_to(content_t m)
332 return content_features(m).buildable_to;
336 Nodes make a face if contents differ and solidness differs.
339 1: Face uses m1's content
340 2: Face uses m2's content
342 inline u8 face_contents(content_t m1, content_t m2)
344 if(m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE)
347 bool contents_differ = (m1 != m2);
349 // Contents don't differ for different forms of same liquid
350 if(content_liquid(m1) && content_liquid(m2)
351 && make_liquid_flowing(m1) == make_liquid_flowing(m2))
352 contents_differ = false;
354 bool solidness_differs = (content_solidness(m1) != content_solidness(m2));
355 bool makes_face = contents_differ && solidness_differs;
357 if(makes_face == false)
360 if(content_solidness(m1) > content_solidness(m2))
367 Packs directions like (1,0,0), (1,-1,0)
369 inline u8 packDir(v3s16 dir)
390 inline v3s16 unpackDir(u8 b)
413 facedir: CPT_FACEDIR_SIMPLE param1 value
414 dir: The face for which stuff is wanted
415 return value: The face from which the stuff is actually found
417 NOTE: Currently this uses 2 bits for Z-,X-,Z+,X+, should there be Y+
420 v3s16 facedir_rotate(u8 facedir, v3s16 dir);
429 Masks for MapNode.param2 of flowing liquids
431 #define LIQUID_LEVEL_MASK 0x07
432 #define LIQUID_FLOW_DOWN_MASK 0x08
434 /* maximum amount of liquid in a block */
435 #define LIQUID_LEVEL_MAX LIQUID_LEVEL_MASK
436 #define LIQUID_LEVEL_SOURCE (LIQUID_LEVEL_MAX+1)
439 This is the stuff what the whole world consists of.
447 0x00-0x7f: Short content type
448 0x80-0xff: Long content type (param2>>4 makes up low bytes)
457 Misc parameter. Initialized to 0.
458 - For light_propagates() blocks, this is light intensity,
459 stored logarithmically from 0 to LIGHT_MAX.
460 Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
461 - Contains 2 values, day- and night lighting. Each takes 4 bits.
462 - Mineral content (should be removed from here)
463 - Uhh... well, most blocks have light or nothing in here.
472 The second parameter. Initialized to 0.
473 E.g. direction for torches and flowing water.
474 If param0 >= 0x80, bits 0xf0 of this is extended content type data
482 MapNode(const MapNode & n)
487 MapNode(content_t content=CONTENT_AIR, u8 a_param1=0, u8 a_param2=0)
492 // Set after other params because this needs to override part of param2
496 bool operator==(const MapNode &other)
498 return (param0 == other.param0
499 && param1 == other.param1
500 && param2 == other.param2);
503 // To be used everywhere
504 content_t getContent()
509 return (param0<<4) + (param2>>4);
511 void setContent(content_t c)
523 param2 |= (c&0x0f)<<4;
528 These four are DEPRECATED I guess. -c55
530 bool light_propagates()
532 return light_propagates_content(getContent());
534 bool sunlight_propagates()
536 return sunlight_propagates_content(getContent());
540 return content_solidness(getContent());
544 return content_features(*this).light_source;
547 u8 getLightBanksWithSource()
549 // Select the brightest of [light source, propagated light]
552 if(content_features(*this).param_type == CPT_LIGHT)
554 lightday = param1 & 0x0f;
555 lightnight = (param1>>4)&0x0f;
557 if(light_source() > lightday)
558 lightday = light_source();
559 if(light_source() > lightnight)
560 lightnight = light_source();
561 return (lightday&0x0f) | ((lightnight<<4)&0xf0);
564 u8 getLight(enum LightBank bank)
566 // Select the brightest of [light source, propagated light]
568 if(content_features(*this).param_type == CPT_LIGHT)
570 if(bank == LIGHTBANK_DAY)
571 light = param1 & 0x0f;
572 else if(bank == LIGHTBANK_NIGHT)
573 light = (param1>>4)&0x0f;
577 if(light_source() > light)
578 light = light_source();
582 // 0 <= daylight_factor <= 1000
583 // 0 <= return value <= LIGHT_SUN
584 u8 getLightBlend(u32 daylight_factor)
586 u8 l = ((daylight_factor * getLight(LIGHTBANK_DAY)
587 + (1000-daylight_factor) * getLight(LIGHTBANK_NIGHT))
590 if(getLight(LIGHTBANK_DAY) == LIGHT_SUN)
596 /*// 0 <= daylight_factor <= 1000
597 // 0 <= return value <= 255
598 u8 getLightBlend(u32 daylight_factor)
600 u8 daylight = decode_light(getLight(LIGHTBANK_DAY));
601 u8 nightlight = decode_light(getLight(LIGHTBANK_NIGHT));
602 u8 mix = ((daylight_factor * daylight
603 + (1000-daylight_factor) * nightlight)
608 void setLight(enum LightBank bank, u8 a_light)
610 // If node doesn't contain light data, ignore this
611 if(content_features(*this).param_type != CPT_LIGHT)
613 if(bank == LIGHTBANK_DAY)
616 param1 |= a_light & 0x0f;
618 else if(bank == LIGHTBANK_NIGHT)
621 param1 |= (a_light & 0x0f)<<4;
629 Get tile of a face of the node.
630 dir: direction of face
631 Returns: TileSpec. Can contain miscellaneous texture coordinates,
632 which must be obeyed so that the texture atlas can be used.
634 TileSpec getTile(v3s16 dir);
637 Gets mineral content of node, if there is any.
638 MINERAL_NONE if doesn't contain or isn't able to contain mineral.
643 Serialization functions
646 static u32 serializedLength(u8 version);
647 void serialize(u8 *dest, u8 version);
648 void deSerialize(u8 *source, u8 version);
653 Gets lighting value at face of node
655 Parameters must consist of air and !air.
656 Order doesn't matter.
658 If either of the nodes doesn't exist, light is 0.
661 daynight_ratio: 0...1000
663 n2: getNodeParent(p + face_dir)
664 face_dir: axis oriented unit vector from p to p2
666 returns encoded light value.
668 u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,