Line data Source code
1 : /*
2 : Minetest
3 : Copyright (C) 2010-2013 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 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 MAPNODE_HEADER
21 : #define MAPNODE_HEADER
22 :
23 : #include "irrlichttypes.h"
24 : #include "irr_v3d.h"
25 : #include "irr_aabb3d.h"
26 : #include "light.h"
27 : #include <string>
28 : #include <vector>
29 :
30 : class INodeDefManager;
31 :
32 : /*
33 : Naming scheme:
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
37 : */
38 : typedef u16 content_t;
39 :
40 : /*
41 : The maximum node ID that can be registered by mods. This must
42 : be significantly lower than the maximum content_t value, so that
43 : there is enough room for dummy node IDs, which are created when
44 : a MapBlock containing unknown node names is loaded from disk.
45 : */
46 : #define MAX_REGISTERED_CONTENT 0x7fffU
47 :
48 : /*
49 : A solid walkable node with the texture unknown_node.png.
50 :
51 : For example, used on the client to display unregistered node IDs
52 : (instead of expanding the vector of node definitions each time
53 : such a node is received).
54 : */
55 : #define CONTENT_UNKNOWN 125
56 :
57 : /*
58 : The common material through which the player can walk and which
59 : is transparent to light
60 : */
61 : #define CONTENT_AIR 126
62 :
63 : /*
64 : Ignored node.
65 :
66 : Unloaded chunks are considered to consist of this. Several other
67 : methods return this when an error occurs. Also, during
68 : map generation this means the node has not been set yet.
69 :
70 : Doesn't create faces with anything and is considered being
71 : out-of-map in the game map.
72 : */
73 : #define CONTENT_IGNORE 127
74 :
75 : enum LightBank
76 : {
77 : LIGHTBANK_DAY,
78 : LIGHTBANK_NIGHT
79 : };
80 :
81 : /*
82 : Simple rotation enum.
83 : */
84 : enum Rotation {
85 : ROTATE_0,
86 : ROTATE_90,
87 : ROTATE_180,
88 : ROTATE_270,
89 : ROTATE_RAND,
90 : };
91 :
92 : /*
93 : Masks for MapNode.param2 of flowing liquids
94 : */
95 : #define LIQUID_LEVEL_MASK 0x07
96 : #define LIQUID_FLOW_DOWN_MASK 0x08
97 :
98 : //#define LIQUID_LEVEL_MASK 0x3f // better finite water
99 : //#define LIQUID_FLOW_DOWN_MASK 0x40 // not used when finite water
100 :
101 : /* maximum amount of liquid in a block */
102 : #define LIQUID_LEVEL_MAX LIQUID_LEVEL_MASK
103 : #define LIQUID_LEVEL_SOURCE (LIQUID_LEVEL_MAX+1)
104 :
105 : #define LIQUID_INFINITY_MASK 0x80 //0b10000000
106 :
107 : // mask for param2, now as for liquid
108 : #define LEVELED_MASK 0x3F
109 : #define LEVELED_MAX LEVELED_MASK
110 :
111 :
112 : struct ContentFeatures;
113 :
114 : /*
115 : This is the stuff what the whole world consists of.
116 : */
117 :
118 :
119 : struct MapNode
120 : {
121 : /*
122 : Main content
123 : */
124 : u16 param0;
125 :
126 : /*
127 : Misc parameter. Initialized to 0.
128 : - For light_propagates() blocks, this is light intensity,
129 : stored logarithmically from 0 to LIGHT_MAX.
130 : Sunlight is LIGHT_SUN, which is LIGHT_MAX+1.
131 : - Contains 2 values, day- and night lighting. Each takes 4 bits.
132 : - Uhh... well, most blocks have light or nothing in here.
133 : */
134 : u8 param1;
135 :
136 : /*
137 : The second parameter. Initialized to 0.
138 : E.g. direction for torches and flowing water.
139 : */
140 : u8 param2;
141 :
142 395977521 : MapNode()
143 395977521 : { }
144 :
145 24672161 : MapNode(const MapNode & n)
146 : {
147 24672161 : *this = n;
148 24672161 : }
149 :
150 3333059 : MapNode(content_t content, u8 a_param1=0, u8 a_param2=0)
151 : : param0(content),
152 : param1(a_param1),
153 3333059 : param2(a_param2)
154 3333059 : { }
155 :
156 : // Create directly from a nodename
157 : // If name is unknown, sets CONTENT_IGNORE
158 : MapNode(INodeDefManager *ndef, const std::string &name,
159 : u8 a_param1=0, u8 a_param2=0);
160 :
161 0 : bool operator==(const MapNode &other)
162 : {
163 0 : return (param0 == other.param0
164 0 : && param1 == other.param1
165 0 : && param2 == other.param2);
166 : }
167 :
168 : // To be used everywhere
169 187393413 : content_t getContent() const
170 : {
171 187393413 : return param0;
172 : }
173 0 : void setContent(content_t c)
174 : {
175 0 : param0 = c;
176 0 : }
177 0 : u8 getParam1() const
178 : {
179 0 : return param1;
180 : }
181 0 : void setParam1(u8 p)
182 : {
183 0 : param1 = p;
184 0 : }
185 86714 : u8 getParam2() const
186 : {
187 86714 : return param2;
188 : }
189 0 : void setParam2(u8 p)
190 : {
191 0 : param2 = p;
192 0 : }
193 :
194 : void setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr);
195 :
196 : /**
197 : * Check if the light value for night differs from the light value for day.
198 : *
199 : * @return If the light values are equal, returns true; otherwise false
200 : */
201 : bool isLightDayNightEq(INodeDefManager *nodemgr) const;
202 :
203 : u8 getLight(enum LightBank bank, INodeDefManager *nodemgr) const;
204 :
205 : /**
206 : * This function differs from getLight(enum LightBank bank, INodeDefManager *nodemgr)
207 : * in that the ContentFeatures of the node in question are not retrieved by
208 : * the function itself. Thus, if you have already called nodemgr->get() to
209 : * get the ContentFeatures you pass it to this function instead of the
210 : * function getting ContentFeatures itself. Since INodeDefManager::get()
211 : * is relatively expensive this can lead to significant performance
212 : * improvements in some situations. Call this function if (and only if)
213 : * you have already retrieved the ContentFeatures by calling
214 : * INodeDefManager::get() for the node you're working with and the
215 : * pre-conditions listed are true.
216 : *
217 : * @pre f != NULL
218 : * @pre f->param_type == CPT_LIGHT
219 : */
220 : u8 getLightNoChecks(LightBank bank, const ContentFeatures *f) const;
221 :
222 : bool getLightBanks(u8 &lightday, u8 &lightnight, INodeDefManager *nodemgr) const;
223 :
224 : // 0 <= daylight_factor <= 1000
225 : // 0 <= return value <= LIGHT_SUN
226 214126 : u8 getLightBlend(u32 daylight_factor, INodeDefManager *nodemgr) const
227 : {
228 214126 : u8 lightday = 0;
229 214126 : u8 lightnight = 0;
230 214126 : getLightBanks(lightday, lightnight, nodemgr);
231 214126 : return blend_light(daylight_factor, lightday, lightnight);
232 : }
233 :
234 : u8 getFaceDir(INodeDefManager *nodemgr) const;
235 : u8 getWallMounted(INodeDefManager *nodemgr) const;
236 : v3s16 getWallMountedDir(INodeDefManager *nodemgr) const;
237 :
238 : void rotateAlongYAxis(INodeDefManager *nodemgr, Rotation rot);
239 :
240 : /*
241 : Gets list of node boxes (used for rendering (NDT_NODEBOX))
242 : */
243 : std::vector<aabb3f> getNodeBoxes(INodeDefManager *nodemgr) const;
244 :
245 : /*
246 : Gets list of selection boxes
247 : */
248 : std::vector<aabb3f> getSelectionBoxes(INodeDefManager *nodemgr) const;
249 :
250 : /*
251 : Gets list of collision boxes
252 : */
253 : std::vector<aabb3f> getCollisionBoxes(INodeDefManager *nodemgr) const;
254 :
255 : /*
256 : Liquid helpers
257 : */
258 : u8 getMaxLevel(INodeDefManager *nodemgr) const;
259 : u8 getLevel(INodeDefManager *nodemgr) const;
260 : u8 setLevel(INodeDefManager *nodemgr, s8 level = 1);
261 : u8 addLevel(INodeDefManager *nodemgr, s8 add = 1);
262 :
263 : /*
264 : Serialization functions
265 : */
266 :
267 : static u32 serializedLength(u8 version);
268 : void serialize(u8 *dest, u8 version);
269 : void deSerialize(u8 *source, u8 version);
270 :
271 : // Serializes or deserializes a list of nodes in bulk format (first the
272 : // content of all nodes, then the param1 of all nodes, then the param2
273 : // of all nodes).
274 : // version = serialization version. Must be >= 22
275 : // content_width = the number of bytes of content per node
276 : // params_width = the number of bytes of params per node
277 : // compressed = true to zlib-compress output
278 : static void serializeBulk(std::ostream &os, int version,
279 : const MapNode *nodes, u32 nodecount,
280 : u8 content_width, u8 params_width, bool compressed);
281 : static void deSerializeBulk(std::istream &is, int version,
282 : MapNode *nodes, u32 nodecount,
283 : u8 content_width, u8 params_width, bool compressed);
284 :
285 : private:
286 : // Deprecated serialization methods
287 : void deSerialize_pre22(u8 *source, u8 version);
288 : };
289 :
290 : #endif
291 :
|
