2011-11-14 20:41:30 +01:00
|
|
|
/*
|
2013-02-24 18:40:43 +01:00
|
|
|
Minetest
|
2013-02-24 19:38:45 +01:00
|
|
|
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2011-11-14 20:41:30 +01:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 16:56:56 +02:00
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2011-11-14 20:41:30 +01:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2012-06-05 16:56:56 +02:00
|
|
|
GNU Lesser General Public License for more details.
|
2011-11-14 20:41:30 +01:00
|
|
|
|
2012-06-05 16:56:56 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2011-11-14 20:41:30 +01:00
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "nodedef.h"
|
|
|
|
|
2012-01-12 06:10:39 +01:00
|
|
|
#include "itemdef.h"
|
2011-11-14 20:41:30 +01:00
|
|
|
#ifndef SERVER
|
2018-11-28 20:01:49 +01:00
|
|
|
#include "client/mesh.h"
|
|
|
|
#include "client/shader.h"
|
|
|
|
#include "client/client.h"
|
2017-06-26 20:11:17 +02:00
|
|
|
#include "client/renderingengine.h"
|
|
|
|
#include "client/tile.h"
|
2014-10-21 05:12:15 +02:00
|
|
|
#include <IMeshManipulator.h>
|
2011-11-14 20:41:30 +01:00
|
|
|
#endif
|
|
|
|
#include "log.h"
|
2011-11-15 18:58:36 +01:00
|
|
|
#include "settings.h"
|
2011-11-16 12:03:28 +01:00
|
|
|
#include "nameidmapping.h"
|
2013-07-14 00:55:47 +02:00
|
|
|
#include "util/numeric.h"
|
2012-06-17 01:40:36 +02:00
|
|
|
#include "util/serialize.h"
|
2014-09-12 00:22:05 +02:00
|
|
|
#include "exceptions.h"
|
|
|
|
#include "debug.h"
|
2014-10-15 04:13:53 +02:00
|
|
|
#include "gamedef.h"
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
#include "mapnode.h"
|
2015-03-30 12:55:29 +02:00
|
|
|
#include <fstream> // Used in applyTextureOverrides()
|
2017-09-11 15:51:40 +02:00
|
|
|
#include <algorithm>
|
2017-10-25 15:23:24 +02:00
|
|
|
#include <cmath>
|
2011-11-15 18:58:36 +01:00
|
|
|
|
2011-11-15 21:41:49 +01:00
|
|
|
/*
|
|
|
|
NodeBox
|
|
|
|
*/
|
|
|
|
|
2012-03-19 04:25:09 +01:00
|
|
|
void NodeBox::reset()
|
|
|
|
{
|
|
|
|
type = NODEBOX_REGULAR;
|
|
|
|
// default is empty
|
|
|
|
fixed.clear();
|
|
|
|
// default is sign/ladder-like
|
|
|
|
wall_top = aabb3f(-BS/2, BS/2-BS/16., -BS/2, BS/2, BS/2, BS/2);
|
|
|
|
wall_bottom = aabb3f(-BS/2, -BS/2, -BS/2, BS/2, -BS/2+BS/16., BS/2);
|
|
|
|
wall_side = aabb3f(-BS/2, -BS/2, -BS/2, -BS/2+BS/16., BS/2, BS/2);
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
// no default for other parts
|
|
|
|
connect_top.clear();
|
|
|
|
connect_bottom.clear();
|
|
|
|
connect_front.clear();
|
|
|
|
connect_left.clear();
|
|
|
|
connect_back.clear();
|
|
|
|
connect_right.clear();
|
2017-04-22 21:17:46 +02:00
|
|
|
disconnected_top.clear();
|
|
|
|
disconnected_bottom.clear();
|
|
|
|
disconnected_front.clear();
|
|
|
|
disconnected_left.clear();
|
|
|
|
disconnected_back.clear();
|
|
|
|
disconnected_right.clear();
|
|
|
|
disconnected.clear();
|
|
|
|
disconnected_sides.clear();
|
2012-03-19 04:25:09 +01:00
|
|
|
}
|
|
|
|
|
2013-08-01 22:50:58 +02:00
|
|
|
void NodeBox::serialize(std::ostream &os, u16 protocol_version) const
|
2011-11-15 18:58:36 +01:00
|
|
|
{
|
2017-08-29 19:26:55 +02:00
|
|
|
// Protocol >= 36
|
2019-01-03 17:04:26 +01:00
|
|
|
const u8 version = 6;
|
2013-08-01 22:50:58 +02:00
|
|
|
writeU8(os, version);
|
|
|
|
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
switch (type) {
|
|
|
|
case NODEBOX_LEVELED:
|
|
|
|
case NODEBOX_FIXED:
|
2017-08-29 19:26:55 +02:00
|
|
|
writeU8(os, type);
|
2012-03-19 04:25:09 +01:00
|
|
|
|
|
|
|
writeU16(os, fixed.size());
|
2017-08-19 11:30:46 +02:00
|
|
|
for (const aabb3f &nodebox : fixed) {
|
2019-01-03 17:04:26 +01:00
|
|
|
writeV3F32(os, nodebox.MinEdge);
|
|
|
|
writeV3F32(os, nodebox.MaxEdge);
|
2012-03-19 04:25:09 +01:00
|
|
|
}
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
break;
|
|
|
|
case NODEBOX_WALLMOUNTED:
|
|
|
|
writeU8(os, type);
|
|
|
|
|
2019-01-03 17:04:26 +01:00
|
|
|
writeV3F32(os, wall_top.MinEdge);
|
|
|
|
writeV3F32(os, wall_top.MaxEdge);
|
|
|
|
writeV3F32(os, wall_bottom.MinEdge);
|
|
|
|
writeV3F32(os, wall_bottom.MaxEdge);
|
|
|
|
writeV3F32(os, wall_side.MinEdge);
|
|
|
|
writeV3F32(os, wall_side.MaxEdge);
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
break;
|
|
|
|
case NODEBOX_CONNECTED:
|
2017-08-29 19:26:55 +02:00
|
|
|
writeU8(os, type);
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
|
2017-08-19 11:30:46 +02:00
|
|
|
#define WRITEBOX(box) \
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
writeU16(os, (box).size()); \
|
2017-08-19 11:30:46 +02:00
|
|
|
for (const aabb3f &i: (box)) { \
|
2019-01-03 17:04:26 +01:00
|
|
|
writeV3F32(os, i.MinEdge); \
|
|
|
|
writeV3F32(os, i.MaxEdge); \
|
2017-08-19 11:30:46 +02:00
|
|
|
};
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
|
2017-08-29 19:26:55 +02:00
|
|
|
WRITEBOX(fixed);
|
|
|
|
WRITEBOX(connect_top);
|
|
|
|
WRITEBOX(connect_bottom);
|
|
|
|
WRITEBOX(connect_front);
|
|
|
|
WRITEBOX(connect_left);
|
|
|
|
WRITEBOX(connect_back);
|
|
|
|
WRITEBOX(connect_right);
|
2017-04-22 21:17:46 +02:00
|
|
|
WRITEBOX(disconnected_top);
|
|
|
|
WRITEBOX(disconnected_bottom);
|
|
|
|
WRITEBOX(disconnected_front);
|
|
|
|
WRITEBOX(disconnected_left);
|
|
|
|
WRITEBOX(disconnected_back);
|
|
|
|
WRITEBOX(disconnected_right);
|
|
|
|
WRITEBOX(disconnected);
|
|
|
|
WRITEBOX(disconnected_sides);
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
writeU8(os, type);
|
|
|
|
break;
|
2012-03-19 04:25:09 +01:00
|
|
|
}
|
2011-11-15 18:58:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void NodeBox::deSerialize(std::istream &is)
|
|
|
|
{
|
|
|
|
int version = readU8(is);
|
2019-01-03 17:04:26 +01:00
|
|
|
if (version < 6)
|
2011-11-15 18:58:36 +01:00
|
|
|
throw SerializationError("unsupported NodeBox version");
|
2012-03-19 04:25:09 +01:00
|
|
|
|
|
|
|
reset();
|
|
|
|
|
2011-11-15 18:58:36 +01:00
|
|
|
type = (enum NodeBoxType)readU8(is);
|
2012-03-19 04:25:09 +01:00
|
|
|
|
2013-07-13 19:48:14 +02:00
|
|
|
if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED)
|
2012-03-19 04:25:09 +01:00
|
|
|
{
|
|
|
|
u16 fixed_count = readU16(is);
|
|
|
|
while(fixed_count--)
|
|
|
|
{
|
|
|
|
aabb3f box;
|
2019-01-03 17:04:26 +01:00
|
|
|
box.MinEdge = readV3F32(is);
|
|
|
|
box.MaxEdge = readV3F32(is);
|
2012-03-19 04:25:09 +01:00
|
|
|
fixed.push_back(box);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(type == NODEBOX_WALLMOUNTED)
|
|
|
|
{
|
2019-01-03 17:04:26 +01:00
|
|
|
wall_top.MinEdge = readV3F32(is);
|
|
|
|
wall_top.MaxEdge = readV3F32(is);
|
|
|
|
wall_bottom.MinEdge = readV3F32(is);
|
|
|
|
wall_bottom.MaxEdge = readV3F32(is);
|
|
|
|
wall_side.MinEdge = readV3F32(is);
|
|
|
|
wall_side.MaxEdge = readV3F32(is);
|
2012-03-19 04:25:09 +01:00
|
|
|
}
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
else if (type == NODEBOX_CONNECTED)
|
|
|
|
{
|
2017-08-20 19:37:29 +02:00
|
|
|
#define READBOXES(box) { \
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
count = readU16(is); \
|
|
|
|
(box).reserve(count); \
|
|
|
|
while (count--) { \
|
2019-01-03 17:04:26 +01:00
|
|
|
v3f min = readV3F32(is); \
|
|
|
|
v3f max = readV3F32(is); \
|
2017-08-20 19:37:29 +02:00
|
|
|
(box).emplace_back(min, max); }; }
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
|
|
|
|
u16 count;
|
|
|
|
|
|
|
|
READBOXES(fixed);
|
|
|
|
READBOXES(connect_top);
|
|
|
|
READBOXES(connect_bottom);
|
|
|
|
READBOXES(connect_front);
|
|
|
|
READBOXES(connect_left);
|
|
|
|
READBOXES(connect_back);
|
|
|
|
READBOXES(connect_right);
|
2019-01-03 17:04:26 +01:00
|
|
|
READBOXES(disconnected_top);
|
|
|
|
READBOXES(disconnected_bottom);
|
|
|
|
READBOXES(disconnected_front);
|
|
|
|
READBOXES(disconnected_left);
|
|
|
|
READBOXES(disconnected_back);
|
|
|
|
READBOXES(disconnected_right);
|
|
|
|
READBOXES(disconnected);
|
|
|
|
READBOXES(disconnected_sides);
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
}
|
2011-11-15 18:58:36 +01:00
|
|
|
}
|
|
|
|
|
2011-11-15 21:41:49 +01:00
|
|
|
/*
|
2012-06-16 02:40:45 +02:00
|
|
|
TileDef
|
2011-11-15 21:41:49 +01:00
|
|
|
*/
|
2012-11-26 03:16:48 +01:00
|
|
|
|
2017-10-15 09:34:14 +02:00
|
|
|
#define TILE_FLAG_BACKFACE_CULLING (1 << 0)
|
|
|
|
#define TILE_FLAG_TILEABLE_HORIZONTAL (1 << 1)
|
|
|
|
#define TILE_FLAG_TILEABLE_VERTICAL (1 << 2)
|
|
|
|
#define TILE_FLAG_HAS_COLOR (1 << 3)
|
|
|
|
#define TILE_FLAG_HAS_SCALE (1 << 4)
|
|
|
|
#define TILE_FLAG_HAS_ALIGN_STYLE (1 << 5)
|
|
|
|
|
2013-01-25 01:37:19 +01:00
|
|
|
void TileDef::serialize(std::ostream &os, u16 protocol_version) const
|
2011-11-15 18:58:36 +01:00
|
|
|
{
|
2017-08-29 19:26:55 +02:00
|
|
|
// protocol_version >= 36
|
2017-10-15 09:34:14 +02:00
|
|
|
u8 version = 6;
|
2017-08-29 19:26:55 +02:00
|
|
|
writeU8(os, version);
|
2017-03-19 08:44:29 +01:00
|
|
|
|
2020-09-20 13:12:55 +02:00
|
|
|
os << serializeString16(name);
|
2017-08-29 19:26:55 +02:00
|
|
|
animation.serialize(os, version);
|
2017-10-15 09:34:14 +02:00
|
|
|
bool has_scale = scale > 0;
|
|
|
|
u16 flags = 0;
|
|
|
|
if (backface_culling)
|
|
|
|
flags |= TILE_FLAG_BACKFACE_CULLING;
|
|
|
|
if (tileable_horizontal)
|
|
|
|
flags |= TILE_FLAG_TILEABLE_HORIZONTAL;
|
|
|
|
if (tileable_vertical)
|
|
|
|
flags |= TILE_FLAG_TILEABLE_VERTICAL;
|
|
|
|
if (has_color)
|
|
|
|
flags |= TILE_FLAG_HAS_COLOR;
|
|
|
|
if (has_scale)
|
|
|
|
flags |= TILE_FLAG_HAS_SCALE;
|
|
|
|
if (align_style != ALIGN_STYLE_NODE)
|
|
|
|
flags |= TILE_FLAG_HAS_ALIGN_STYLE;
|
|
|
|
writeU16(os, flags);
|
2017-08-29 19:26:55 +02:00
|
|
|
if (has_color) {
|
|
|
|
writeU8(os, color.getRed());
|
|
|
|
writeU8(os, color.getGreen());
|
|
|
|
writeU8(os, color.getBlue());
|
2017-01-12 15:46:30 +01:00
|
|
|
}
|
2017-10-15 09:34:14 +02:00
|
|
|
if (has_scale)
|
|
|
|
writeU8(os, scale);
|
|
|
|
if (align_style != ALIGN_STYLE_NODE)
|
|
|
|
writeU8(os, align_style);
|
2011-11-15 18:58:36 +01:00
|
|
|
}
|
|
|
|
|
2017-08-29 19:26:55 +02:00
|
|
|
void TileDef::deSerialize(std::istream &is, u8 contentfeatures_version,
|
2017-08-29 20:21:14 +02:00
|
|
|
NodeDrawType drawtype)
|
2011-11-15 18:58:36 +01:00
|
|
|
{
|
2012-06-16 02:40:45 +02:00
|
|
|
int version = readU8(is);
|
2017-10-15 09:34:14 +02:00
|
|
|
if (version < 6)
|
|
|
|
throw SerializationError("unsupported TileDef version");
|
2020-09-20 13:12:55 +02:00
|
|
|
name = deSerializeString16(is);
|
2017-08-29 19:26:55 +02:00
|
|
|
animation.deSerialize(is, version);
|
2017-10-15 09:34:14 +02:00
|
|
|
u16 flags = readU16(is);
|
|
|
|
backface_culling = flags & TILE_FLAG_BACKFACE_CULLING;
|
|
|
|
tileable_horizontal = flags & TILE_FLAG_TILEABLE_HORIZONTAL;
|
|
|
|
tileable_vertical = flags & TILE_FLAG_TILEABLE_VERTICAL;
|
|
|
|
has_color = flags & TILE_FLAG_HAS_COLOR;
|
|
|
|
bool has_scale = flags & TILE_FLAG_HAS_SCALE;
|
|
|
|
bool has_align_style = flags & TILE_FLAG_HAS_ALIGN_STYLE;
|
2017-08-29 19:26:55 +02:00
|
|
|
if (has_color) {
|
|
|
|
color.setRed(readU8(is));
|
|
|
|
color.setGreen(readU8(is));
|
|
|
|
color.setBlue(readU8(is));
|
2017-01-12 15:46:30 +01:00
|
|
|
}
|
2017-10-15 09:34:14 +02:00
|
|
|
scale = has_scale ? readU8(is) : 0;
|
|
|
|
if (has_align_style)
|
|
|
|
align_style = static_cast<AlignStyle>(readU8(is));
|
|
|
|
else
|
|
|
|
align_style = ALIGN_STYLE_NODE;
|
2011-11-15 18:58:36 +01:00
|
|
|
}
|
|
|
|
|
2016-05-22 20:33:06 +02:00
|
|
|
void TextureSettings::readSettings()
|
|
|
|
{
|
|
|
|
connected_glass = g_settings->getBool("connected_glass");
|
|
|
|
opaque_water = g_settings->getBool("opaque_water");
|
2017-01-24 22:33:01 +01:00
|
|
|
bool smooth_lighting = g_settings->getBool("smooth_lighting");
|
2016-05-22 20:33:06 +02:00
|
|
|
enable_mesh_cache = g_settings->getBool("enable_mesh_cache");
|
|
|
|
enable_minimap = g_settings->getBool("enable_minimap");
|
2017-10-15 09:34:14 +02:00
|
|
|
node_texture_size = g_settings->getU16("texture_min_size");
|
2016-05-22 20:33:06 +02:00
|
|
|
std::string leaves_style_str = g_settings->get("leaves_style");
|
2017-10-15 09:34:14 +02:00
|
|
|
std::string world_aligned_mode_str = g_settings->get("world_aligned_mode");
|
|
|
|
std::string autoscale_mode_str = g_settings->get("autoscale_mode");
|
2016-05-22 20:33:06 +02:00
|
|
|
|
2017-01-24 22:33:01 +01:00
|
|
|
// Mesh cache is not supported in combination with smooth lighting
|
|
|
|
if (smooth_lighting)
|
|
|
|
enable_mesh_cache = false;
|
|
|
|
|
2016-05-22 20:33:06 +02:00
|
|
|
if (leaves_style_str == "fancy") {
|
|
|
|
leaves_style = LEAVES_FANCY;
|
|
|
|
} else if (leaves_style_str == "simple") {
|
|
|
|
leaves_style = LEAVES_SIMPLE;
|
|
|
|
} else {
|
|
|
|
leaves_style = LEAVES_OPAQUE;
|
|
|
|
}
|
2017-10-15 09:34:14 +02:00
|
|
|
|
|
|
|
if (world_aligned_mode_str == "enable")
|
|
|
|
world_aligned_mode = WORLDALIGN_ENABLE;
|
|
|
|
else if (world_aligned_mode_str == "force_solid")
|
|
|
|
world_aligned_mode = WORLDALIGN_FORCE;
|
|
|
|
else if (world_aligned_mode_str == "force_nodebox")
|
|
|
|
world_aligned_mode = WORLDALIGN_FORCE_NODEBOX;
|
|
|
|
else
|
|
|
|
world_aligned_mode = WORLDALIGN_DISABLE;
|
|
|
|
|
|
|
|
if (autoscale_mode_str == "enable")
|
|
|
|
autoscale_mode = AUTOSCALE_ENABLE;
|
|
|
|
else if (autoscale_mode_str == "force")
|
|
|
|
autoscale_mode = AUTOSCALE_FORCE;
|
|
|
|
else
|
|
|
|
autoscale_mode = AUTOSCALE_DISABLE;
|
2016-05-22 20:33:06 +02:00
|
|
|
}
|
|
|
|
|
2011-11-15 21:41:49 +01:00
|
|
|
/*
|
|
|
|
ContentFeatures
|
|
|
|
*/
|
|
|
|
|
2011-11-15 18:58:36 +01:00
|
|
|
ContentFeatures::ContentFeatures()
|
|
|
|
{
|
|
|
|
reset();
|
|
|
|
}
|
2011-11-14 20:41:30 +01:00
|
|
|
|
2020-07-10 12:11:44 +02:00
|
|
|
ContentFeatures::~ContentFeatures()
|
|
|
|
{
|
|
|
|
#ifndef SERVER
|
|
|
|
for (u16 j = 0; j < 6; j++) {
|
|
|
|
delete tiles[j].layers[0].frames;
|
|
|
|
delete tiles[j].layers[1].frames;
|
|
|
|
}
|
|
|
|
for (u16 j = 0; j < CF_SPECIAL_COUNT; j++)
|
|
|
|
delete special_tiles[j].layers[0].frames;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-11-15 18:58:36 +01:00
|
|
|
void ContentFeatures::reset()
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
Cached stuff
|
|
|
|
*/
|
|
|
|
#ifndef SERVER
|
|
|
|
solidness = 2;
|
|
|
|
visual_solidness = 0;
|
|
|
|
backface_culling = true;
|
2015-07-16 15:36:48 +02:00
|
|
|
|
2011-11-15 18:58:36 +01:00
|
|
|
#endif
|
2012-06-05 22:51:37 +02:00
|
|
|
has_on_construct = false;
|
|
|
|
has_on_destruct = false;
|
|
|
|
has_after_destruct = false;
|
2011-11-15 18:58:36 +01:00
|
|
|
/*
|
|
|
|
Actual data
|
2012-11-26 03:16:48 +01:00
|
|
|
|
2011-11-26 01:26:19 +01:00
|
|
|
NOTE: Most of this is always overridden by the default values given
|
|
|
|
in builtin.lua
|
2011-11-15 18:58:36 +01:00
|
|
|
*/
|
2011-11-16 08:36:19 +01:00
|
|
|
name = "";
|
2012-02-28 18:45:23 +01:00
|
|
|
groups.clear();
|
2012-03-19 07:16:17 +01:00
|
|
|
// Unknown nodes can be dug
|
|
|
|
groups["dig_immediate"] = 2;
|
2011-11-15 18:58:36 +01:00
|
|
|
drawtype = NDT_NORMAL;
|
2014-10-15 04:13:53 +02:00
|
|
|
mesh = "";
|
|
|
|
#ifndef SERVER
|
2017-08-19 11:30:46 +02:00
|
|
|
for (auto &i : mesh_ptr)
|
|
|
|
i = NULL;
|
2015-06-22 04:34:56 +02:00
|
|
|
minimap_color = video::SColor(0, 0, 0, 0);
|
2014-10-15 04:13:53 +02:00
|
|
|
#endif
|
2011-11-15 18:58:36 +01:00
|
|
|
visual_scale = 1.0;
|
2017-08-19 11:30:46 +02:00
|
|
|
for (auto &i : tiledef)
|
|
|
|
i = TileDef();
|
|
|
|
for (auto &j : tiledef_special)
|
|
|
|
j = TileDef();
|
2021-01-17 01:56:50 +01:00
|
|
|
alpha = ALPHAMODE_OPAQUE;
|
2011-11-15 18:58:36 +01:00
|
|
|
post_effect_color = video::SColor(0, 0, 0, 0);
|
|
|
|
param_type = CPT_NONE;
|
2012-01-21 00:11:44 +01:00
|
|
|
param_type_2 = CPT2_NONE;
|
2011-11-15 18:58:36 +01:00
|
|
|
is_ground_content = false;
|
|
|
|
light_propagates = false;
|
|
|
|
sunlight_propagates = false;
|
|
|
|
walkable = true;
|
|
|
|
pointable = true;
|
|
|
|
diggable = true;
|
|
|
|
climbable = false;
|
|
|
|
buildable_to = false;
|
2015-12-30 05:22:58 +01:00
|
|
|
floodable = false;
|
2013-01-27 10:33:25 +01:00
|
|
|
rightclickable = true;
|
2013-07-13 19:48:14 +02:00
|
|
|
leveled = 0;
|
2020-05-19 21:08:37 +02:00
|
|
|
leveled_max = LEVELED_MAX;
|
2011-11-15 18:58:36 +01:00
|
|
|
liquid_type = LIQUID_NONE;
|
2011-11-25 16:00:50 +01:00
|
|
|
liquid_alternative_flowing = "";
|
2020-05-20 23:52:10 +02:00
|
|
|
liquid_alternative_flowing_id = CONTENT_IGNORE;
|
2011-11-25 16:00:50 +01:00
|
|
|
liquid_alternative_source = "";
|
2020-05-20 23:52:10 +02:00
|
|
|
liquid_alternative_source_id = CONTENT_IGNORE;
|
2011-11-15 18:58:36 +01:00
|
|
|
liquid_viscosity = 0;
|
2012-09-07 18:48:12 +02:00
|
|
|
liquid_renewable = true;
|
2013-07-16 16:28:18 +02:00
|
|
|
liquid_range = LIQUID_LEVEL_MAX+1;
|
2013-08-01 18:36:11 +02:00
|
|
|
drowning = 0;
|
2011-11-15 18:58:36 +01:00
|
|
|
light_source = 0;
|
|
|
|
damage_per_second = 0;
|
2012-03-19 04:25:09 +01:00
|
|
|
node_box = NodeBox();
|
2011-11-15 18:58:36 +01:00
|
|
|
selection_box = NodeBox();
|
2014-10-18 18:46:16 +02:00
|
|
|
collision_box = NodeBox();
|
2013-12-03 17:21:40 +01:00
|
|
|
waving = 0;
|
2012-01-21 00:11:44 +01:00
|
|
|
legacy_facedir_simple = false;
|
|
|
|
legacy_wallmounted = false;
|
2012-03-23 19:23:03 +01:00
|
|
|
sound_footstep = SimpleSoundSpec();
|
2012-03-24 10:10:28 +01:00
|
|
|
sound_dig = SimpleSoundSpec("__group");
|
2012-03-24 02:28:08 +01:00
|
|
|
sound_dug = SimpleSoundSpec();
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
connects_to.clear();
|
|
|
|
connects_to_ids.clear();
|
Allow nodes to specify which sides to connect to.
NDT_CONNECTED attempts to connect to any side of nodes that it can
connect to, which is troublesome for FACEDIR type nodes that generally
may only have one usable face, and can be rotated.
We introduce a node parameter `connect_sides` that is valid for
any node type. If specified, it lists faces of the node (in "top",
"bottom", "front", "left", "back", "right", form, as array) that
connecting nodeboxes can connect to. "front" corresponds to the south
facing side of a node with facedir = 0.
If the node is rotatable using *simple* FACEDIR, then the attached
face is properly rotated before checking. This allows e.g. a chest
to be attached to only from the rear side.
2016-03-04 08:18:04 +01:00
|
|
|
connect_sides = 0;
|
2017-01-12 15:46:30 +01:00
|
|
|
color = video::SColor(0xFFFFFFFF);
|
|
|
|
palette_name = "";
|
|
|
|
palette = NULL;
|
2017-09-11 14:50:06 +02:00
|
|
|
node_dig_prediction = "air";
|
2011-11-15 18:58:36 +01:00
|
|
|
}
|
|
|
|
|
2021-01-17 01:56:50 +01:00
|
|
|
void ContentFeatures::setAlphaFromLegacy(u8 legacy_alpha)
|
|
|
|
{
|
|
|
|
// No special handling for nodebox/mesh here as it doesn't make sense to
|
|
|
|
// throw warnings when the server is too old to support the "correct" way
|
|
|
|
switch (drawtype) {
|
|
|
|
case NDT_NORMAL:
|
|
|
|
alpha = legacy_alpha == 255 ? ALPHAMODE_OPAQUE : ALPHAMODE_CLIP;
|
|
|
|
break;
|
|
|
|
case NDT_LIQUID:
|
|
|
|
case NDT_FLOWINGLIQUID:
|
|
|
|
alpha = legacy_alpha == 255 ? ALPHAMODE_OPAQUE : ALPHAMODE_BLEND;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
alpha = legacy_alpha == 255 ? ALPHAMODE_CLIP : ALPHAMODE_BLEND;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u8 ContentFeatures::getAlphaForLegacy() const
|
|
|
|
{
|
|
|
|
// This is so simple only because 255 and 0 mean wildly different things
|
|
|
|
// depending on drawtype...
|
|
|
|
return alpha == ALPHAMODE_OPAQUE ? 255 : 0;
|
|
|
|
}
|
|
|
|
|
2015-05-05 22:52:06 +02:00
|
|
|
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
|
2011-11-15 18:58:36 +01:00
|
|
|
{
|
2019-01-03 17:04:26 +01:00
|
|
|
const u8 version = CONTENTFEATURES_VERSION;
|
2017-06-11 21:20:50 +02:00
|
|
|
writeU8(os, version);
|
2016-01-24 04:53:27 +01:00
|
|
|
|
2017-01-12 15:46:30 +01:00
|
|
|
// general
|
2020-09-20 13:12:55 +02:00
|
|
|
os << serializeString16(name);
|
2012-02-28 18:45:23 +01:00
|
|
|
writeU16(os, groups.size());
|
2017-08-19 11:30:46 +02:00
|
|
|
for (const auto &group : groups) {
|
2020-09-20 13:12:55 +02:00
|
|
|
os << serializeString16(group.first);
|
2017-08-19 11:30:46 +02:00
|
|
|
writeS16(os, group.second);
|
2012-02-28 18:45:23 +01:00
|
|
|
}
|
2017-01-12 15:46:30 +01:00
|
|
|
writeU8(os, param_type);
|
|
|
|
writeU8(os, param_type_2);
|
|
|
|
|
|
|
|
// visual
|
2011-11-15 18:58:36 +01:00
|
|
|
writeU8(os, drawtype);
|
2020-09-20 13:12:55 +02:00
|
|
|
os << serializeString16(mesh);
|
2019-01-03 17:04:26 +01:00
|
|
|
writeF32(os, visual_scale);
|
2011-11-15 18:58:36 +01:00
|
|
|
writeU8(os, 6);
|
2017-08-19 11:30:46 +02:00
|
|
|
for (const TileDef &td : tiledef)
|
|
|
|
td.serialize(os, protocol_version);
|
|
|
|
for (const TileDef &td : tiledef_overlay)
|
|
|
|
td.serialize(os, protocol_version);
|
2011-11-15 18:58:36 +01:00
|
|
|
writeU8(os, CF_SPECIAL_COUNT);
|
2017-08-19 11:30:46 +02:00
|
|
|
for (const TileDef &td : tiledef_special) {
|
|
|
|
td.serialize(os, protocol_version);
|
2011-11-15 18:58:36 +01:00
|
|
|
}
|
2021-01-17 01:56:50 +01:00
|
|
|
writeU8(os, getAlphaForLegacy());
|
2017-01-12 15:46:30 +01:00
|
|
|
writeU8(os, color.getRed());
|
|
|
|
writeU8(os, color.getGreen());
|
|
|
|
writeU8(os, color.getBlue());
|
2020-09-20 13:12:55 +02:00
|
|
|
os << serializeString16(palette_name);
|
2017-01-12 15:46:30 +01:00
|
|
|
writeU8(os, waving);
|
|
|
|
writeU8(os, connect_sides);
|
|
|
|
writeU16(os, connects_to_ids.size());
|
2017-08-19 11:30:46 +02:00
|
|
|
for (u16 connects_to_id : connects_to_ids)
|
|
|
|
writeU16(os, connects_to_id);
|
2019-01-03 17:04:26 +01:00
|
|
|
writeARGB8(os, post_effect_color);
|
2017-01-12 15:46:30 +01:00
|
|
|
writeU8(os, leveled);
|
|
|
|
|
|
|
|
// lighting
|
2011-11-15 18:58:36 +01:00
|
|
|
writeU8(os, light_propagates);
|
|
|
|
writeU8(os, sunlight_propagates);
|
2017-01-12 15:46:30 +01:00
|
|
|
writeU8(os, light_source);
|
|
|
|
|
|
|
|
// map generation
|
|
|
|
writeU8(os, is_ground_content);
|
|
|
|
|
|
|
|
// interaction
|
2011-11-15 18:58:36 +01:00
|
|
|
writeU8(os, walkable);
|
|
|
|
writeU8(os, pointable);
|
|
|
|
writeU8(os, diggable);
|
|
|
|
writeU8(os, climbable);
|
|
|
|
writeU8(os, buildable_to);
|
2017-01-12 15:46:30 +01:00
|
|
|
writeU8(os, rightclickable);
|
|
|
|
writeU32(os, damage_per_second);
|
|
|
|
|
|
|
|
// liquid
|
2011-11-15 18:58:36 +01:00
|
|
|
writeU8(os, liquid_type);
|
2020-09-20 13:12:55 +02:00
|
|
|
os << serializeString16(liquid_alternative_flowing);
|
|
|
|
os << serializeString16(liquid_alternative_source);
|
2011-11-15 18:58:36 +01:00
|
|
|
writeU8(os, liquid_viscosity);
|
2012-11-25 20:11:45 +01:00
|
|
|
writeU8(os, liquid_renewable);
|
2017-01-12 15:46:30 +01:00
|
|
|
writeU8(os, liquid_range);
|
|
|
|
writeU8(os, drowning);
|
|
|
|
writeU8(os, floodable);
|
|
|
|
|
|
|
|
// node boxes
|
2013-08-01 22:50:58 +02:00
|
|
|
node_box.serialize(os, protocol_version);
|
|
|
|
selection_box.serialize(os, protocol_version);
|
2017-01-12 15:46:30 +01:00
|
|
|
collision_box.serialize(os, protocol_version);
|
|
|
|
|
|
|
|
// sound
|
2019-01-03 17:04:26 +01:00
|
|
|
sound_footstep.serialize(os, version);
|
|
|
|
sound_dig.serialize(os, version);
|
|
|
|
sound_dug.serialize(os, version);
|
2017-01-12 15:46:30 +01:00
|
|
|
|
|
|
|
// legacy
|
|
|
|
writeU8(os, legacy_facedir_simple);
|
|
|
|
writeU8(os, legacy_wallmounted);
|
2017-09-11 14:50:06 +02:00
|
|
|
|
2020-09-20 13:12:55 +02:00
|
|
|
os << serializeString16(node_dig_prediction);
|
2020-05-19 21:08:37 +02:00
|
|
|
writeU8(os, leveled_max);
|
2021-01-17 01:56:50 +01:00
|
|
|
writeU8(os, alpha);
|
2017-01-12 15:46:30 +01:00
|
|
|
}
|
|
|
|
|
2012-01-12 06:10:39 +01:00
|
|
|
void ContentFeatures::deSerialize(std::istream &is)
|
2011-11-15 18:58:36 +01:00
|
|
|
{
|
2017-01-12 15:46:30 +01:00
|
|
|
// version detection
|
2019-01-03 17:04:26 +01:00
|
|
|
const u8 version = readU8(is);
|
|
|
|
if (version < CONTENTFEATURES_VERSION)
|
2016-01-24 04:53:27 +01:00
|
|
|
throw SerializationError("unsupported ContentFeatures version");
|
2012-11-26 22:59:03 +01:00
|
|
|
|
2017-01-12 15:46:30 +01:00
|
|
|
// general
|
2020-09-20 13:12:55 +02:00
|
|
|
name = deSerializeString16(is);
|
2012-11-26 22:59:03 +01:00
|
|
|
groups.clear();
|
|
|
|
u32 groups_size = readU16(is);
|
2017-01-12 15:46:30 +01:00
|
|
|
for (u32 i = 0; i < groups_size; i++) {
|
2020-09-20 13:12:55 +02:00
|
|
|
std::string name = deSerializeString16(is);
|
2012-11-26 22:59:03 +01:00
|
|
|
int value = readS16(is);
|
|
|
|
groups[name] = value;
|
2012-02-28 18:45:23 +01:00
|
|
|
}
|
2017-01-12 15:46:30 +01:00
|
|
|
param_type = (enum ContentParamType) readU8(is);
|
|
|
|
param_type_2 = (enum ContentParamType2) readU8(is);
|
Backface culling: Ignore setting in tiledef from old servers.
Outdated servers are always sending tiledefs with culling
enabled no matter what, as the value was previously entirely
ignored.
To compensate, we must (1) detect that we're running against
an old server with a new client, and (2) disable culling for
mesh, plantlike, firelike and liquid draw types no matter what
the server is telling us.
In order to achieve this, we need to bump the protocol version
since we cannot rely on the tiledef version, and test for it
being older. I've bumped the protocol version, although that
should have likely happened in the actual change that introduced
the new backface_culling PR #3578. Fortunately that's only 2
commits back at this point.
We also explicitly test for the drawtype to assure we are not
changing the culling value for other nodes, where it should
remain enabled.
This was tested against various pub servers, including 0.4.13 and
0.4.12.
Fixes #3598
2016-01-21 23:40:24 +01:00
|
|
|
|
2017-01-12 15:46:30 +01:00
|
|
|
// visual
|
|
|
|
drawtype = (enum NodeDrawType) readU8(is);
|
2020-09-20 13:12:55 +02:00
|
|
|
mesh = deSerializeString16(is);
|
2019-01-03 17:04:26 +01:00
|
|
|
visual_scale = readF32(is);
|
2017-01-12 15:46:30 +01:00
|
|
|
if (readU8(is) != 6)
|
2012-11-26 22:59:03 +01:00
|
|
|
throw SerializationError("unsupported tile count");
|
2017-08-19 11:30:46 +02:00
|
|
|
for (TileDef &td : tiledef)
|
|
|
|
td.deSerialize(is, version, drawtype);
|
2017-08-29 19:26:55 +02:00
|
|
|
for (TileDef &td : tiledef_overlay)
|
|
|
|
td.deSerialize(is, version, drawtype);
|
2017-01-12 15:46:30 +01:00
|
|
|
if (readU8(is) != CF_SPECIAL_COUNT)
|
2012-11-26 22:59:03 +01:00
|
|
|
throw SerializationError("unsupported CF_SPECIAL_COUNT");
|
2017-08-19 11:30:46 +02:00
|
|
|
for (TileDef &td : tiledef_special)
|
|
|
|
td.deSerialize(is, version, drawtype);
|
2021-01-17 01:56:50 +01:00
|
|
|
setAlphaFromLegacy(readU8(is));
|
2017-01-12 15:46:30 +01:00
|
|
|
color.setRed(readU8(is));
|
|
|
|
color.setGreen(readU8(is));
|
|
|
|
color.setBlue(readU8(is));
|
2020-09-20 13:12:55 +02:00
|
|
|
palette_name = deSerializeString16(is);
|
2017-01-12 15:46:30 +01:00
|
|
|
waving = readU8(is);
|
|
|
|
connect_sides = readU8(is);
|
|
|
|
u16 connects_to_size = readU16(is);
|
|
|
|
connects_to_ids.clear();
|
|
|
|
for (u16 i = 0; i < connects_to_size; i++)
|
2017-09-11 15:51:40 +02:00
|
|
|
connects_to_ids.push_back(readU16(is));
|
2019-01-03 17:04:26 +01:00
|
|
|
post_effect_color = readARGB8(is);
|
2017-01-12 15:46:30 +01:00
|
|
|
leveled = readU8(is);
|
|
|
|
|
|
|
|
// lighting-related
|
2012-11-26 22:59:03 +01:00
|
|
|
light_propagates = readU8(is);
|
|
|
|
sunlight_propagates = readU8(is);
|
2017-01-12 15:46:30 +01:00
|
|
|
light_source = readU8(is);
|
|
|
|
light_source = MYMIN(light_source, LIGHT_MAX);
|
|
|
|
|
|
|
|
// map generation
|
|
|
|
is_ground_content = readU8(is);
|
|
|
|
|
|
|
|
// interaction
|
2012-11-26 22:59:03 +01:00
|
|
|
walkable = readU8(is);
|
|
|
|
pointable = readU8(is);
|
|
|
|
diggable = readU8(is);
|
|
|
|
climbable = readU8(is);
|
|
|
|
buildable_to = readU8(is);
|
2017-01-12 15:46:30 +01:00
|
|
|
rightclickable = readU8(is);
|
|
|
|
damage_per_second = readU32(is);
|
|
|
|
|
|
|
|
// liquid
|
|
|
|
liquid_type = (enum LiquidType) readU8(is);
|
2020-09-20 13:12:55 +02:00
|
|
|
liquid_alternative_flowing = deSerializeString16(is);
|
|
|
|
liquid_alternative_source = deSerializeString16(is);
|
2012-11-26 22:59:03 +01:00
|
|
|
liquid_viscosity = readU8(is);
|
|
|
|
liquid_renewable = readU8(is);
|
2017-01-12 15:46:30 +01:00
|
|
|
liquid_range = readU8(is);
|
|
|
|
drowning = readU8(is);
|
|
|
|
floodable = readU8(is);
|
|
|
|
|
|
|
|
// node boxes
|
2012-11-26 22:59:03 +01:00
|
|
|
node_box.deSerialize(is);
|
|
|
|
selection_box.deSerialize(is);
|
2017-01-12 15:46:30 +01:00
|
|
|
collision_box.deSerialize(is);
|
|
|
|
|
|
|
|
// sounds
|
2019-01-03 17:04:26 +01:00
|
|
|
sound_footstep.deSerialize(is, version);
|
|
|
|
sound_dig.deSerialize(is, version);
|
|
|
|
sound_dug.deSerialize(is, version);
|
2017-01-12 15:46:30 +01:00
|
|
|
|
|
|
|
// read legacy properties
|
|
|
|
legacy_facedir_simple = readU8(is);
|
|
|
|
legacy_wallmounted = readU8(is);
|
2017-09-11 14:50:06 +02:00
|
|
|
|
|
|
|
try {
|
2020-09-20 13:12:55 +02:00
|
|
|
node_dig_prediction = deSerializeString16(is);
|
2021-01-17 01:56:50 +01:00
|
|
|
|
|
|
|
u8 tmp = readU8(is);
|
2020-05-19 21:08:37 +02:00
|
|
|
if (is.eof()) /* readU8 doesn't throw exceptions so we have to do this */
|
|
|
|
throw SerializationError("");
|
2021-01-17 01:56:50 +01:00
|
|
|
leveled_max = tmp;
|
|
|
|
|
|
|
|
tmp = readU8(is);
|
|
|
|
if (is.eof())
|
|
|
|
throw SerializationError("");
|
|
|
|
alpha = static_cast<enum AlphaMode>(tmp);
|
2017-09-11 14:50:06 +02:00
|
|
|
} catch(SerializationError &e) {};
|
2011-11-15 13:43:15 +01:00
|
|
|
}
|
|
|
|
|
2016-05-22 20:33:06 +02:00
|
|
|
#ifndef SERVER
|
2017-10-15 09:34:14 +02:00
|
|
|
static void fillTileAttribs(ITextureSource *tsrc, TileLayer *layer,
|
|
|
|
const TileSpec &tile, const TileDef &tiledef, video::SColor color,
|
|
|
|
u8 material_type, u32 shader_id, bool backface_culling,
|
|
|
|
const TextureSettings &tsettings)
|
2016-05-22 20:33:06 +02:00
|
|
|
{
|
2017-10-15 09:34:14 +02:00
|
|
|
layer->shader_id = shader_id;
|
|
|
|
layer->texture = tsrc->getTextureForMesh(tiledef.name, &layer->texture_id);
|
|
|
|
layer->material_type = material_type;
|
|
|
|
|
|
|
|
bool has_scale = tiledef.scale > 0;
|
2020-06-01 21:19:35 +02:00
|
|
|
bool use_autoscale = tsettings.autoscale_mode == AUTOSCALE_FORCE ||
|
|
|
|
(tsettings.autoscale_mode == AUTOSCALE_ENABLE && !has_scale);
|
2020-12-23 22:03:49 +01:00
|
|
|
if (use_autoscale) {
|
2017-10-15 09:34:14 +02:00
|
|
|
auto texture_size = layer->texture->getOriginalSize();
|
|
|
|
float base_size = tsettings.node_texture_size;
|
|
|
|
float size = std::fmin(texture_size.Width, texture_size.Height);
|
|
|
|
layer->scale = std::fmax(base_size, size) / base_size;
|
|
|
|
} else if (has_scale) {
|
|
|
|
layer->scale = tiledef.scale;
|
|
|
|
} else {
|
|
|
|
layer->scale = 1;
|
|
|
|
}
|
|
|
|
if (!tile.world_aligned)
|
|
|
|
layer->scale = 1;
|
2016-05-22 20:33:06 +02:00
|
|
|
|
2017-10-15 09:34:14 +02:00
|
|
|
layer->flags_texture = tsrc->getShaderFlagsTexture(layer->normal_texture ? true : false);
|
2016-05-22 20:33:06 +02:00
|
|
|
|
|
|
|
// Material flags
|
2017-10-15 09:34:14 +02:00
|
|
|
layer->material_flags = 0;
|
2016-05-22 20:33:06 +02:00
|
|
|
if (backface_culling)
|
2017-10-15 09:34:14 +02:00
|
|
|
layer->material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
|
|
|
|
if (tiledef.animation.type != TAT_NONE)
|
|
|
|
layer->material_flags |= MATERIAL_FLAG_ANIMATION;
|
|
|
|
if (tiledef.tileable_horizontal)
|
|
|
|
layer->material_flags |= MATERIAL_FLAG_TILEABLE_HORIZONTAL;
|
|
|
|
if (tiledef.tileable_vertical)
|
|
|
|
layer->material_flags |= MATERIAL_FLAG_TILEABLE_VERTICAL;
|
2016-05-22 20:33:06 +02:00
|
|
|
|
2017-01-12 15:46:30 +01:00
|
|
|
// Color
|
2017-10-15 09:34:14 +02:00
|
|
|
layer->has_color = tiledef.has_color;
|
|
|
|
if (tiledef.has_color)
|
|
|
|
layer->color = tiledef.color;
|
2017-01-12 15:46:30 +01:00
|
|
|
else
|
2017-10-15 09:34:14 +02:00
|
|
|
layer->color = color;
|
2017-01-12 15:46:30 +01:00
|
|
|
|
2016-05-22 20:33:06 +02:00
|
|
|
// Animation parameters
|
|
|
|
int frame_count = 1;
|
2017-10-15 09:34:14 +02:00
|
|
|
if (layer->material_flags & MATERIAL_FLAG_ANIMATION) {
|
2016-12-23 13:48:32 +01:00
|
|
|
int frame_length_ms;
|
2017-10-15 09:34:14 +02:00
|
|
|
tiledef.animation.determineParams(layer->texture->getOriginalSize(),
|
2017-01-14 16:48:49 +01:00
|
|
|
&frame_count, &frame_length_ms, NULL);
|
2017-10-15 09:34:14 +02:00
|
|
|
layer->animation_frame_count = frame_count;
|
|
|
|
layer->animation_frame_length_ms = frame_length_ms;
|
2016-05-22 20:33:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (frame_count == 1) {
|
2017-10-15 09:34:14 +02:00
|
|
|
layer->material_flags &= ~MATERIAL_FLAG_ANIMATION;
|
2016-05-22 20:33:06 +02:00
|
|
|
} else {
|
|
|
|
std::ostringstream os(std::ios::binary);
|
2017-10-15 09:34:14 +02:00
|
|
|
if (!layer->frames) {
|
2020-07-10 12:11:44 +02:00
|
|
|
layer->frames = new std::vector<FrameSpec>();
|
2017-07-26 20:12:48 +02:00
|
|
|
}
|
2017-10-15 09:34:14 +02:00
|
|
|
layer->frames->resize(frame_count);
|
2016-05-22 20:33:06 +02:00
|
|
|
|
|
|
|
for (int i = 0; i < frame_count; i++) {
|
|
|
|
|
|
|
|
FrameSpec frame;
|
|
|
|
|
|
|
|
os.str("");
|
2017-10-15 09:34:14 +02:00
|
|
|
os << tiledef.name;
|
|
|
|
tiledef.animation.getTextureModifer(os,
|
|
|
|
layer->texture->getOriginalSize(), i);
|
2016-05-22 20:33:06 +02:00
|
|
|
|
|
|
|
frame.texture = tsrc->getTextureForMesh(os.str(), &frame.texture_id);
|
2017-10-15 09:34:14 +02:00
|
|
|
if (layer->normal_texture)
|
2016-05-22 20:33:06 +02:00
|
|
|
frame.normal_texture = tsrc->getNormalTexture(os.str());
|
2017-10-15 09:34:14 +02:00
|
|
|
frame.flags_texture = layer->flags_texture;
|
|
|
|
(*layer->frames)[i] = frame;
|
2016-05-22 20:33:06 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-12 11:52:50 +02:00
|
|
|
bool ContentFeatures::textureAlphaCheck(ITextureSource *tsrc, const TileDef *tiles, int length)
|
|
|
|
{
|
|
|
|
video::IVideoDriver *driver = RenderingEngine::get_video_driver();
|
|
|
|
static thread_local bool long_warning_printed = false;
|
|
|
|
std::set<std::string> seen;
|
2021-01-17 01:56:50 +01:00
|
|
|
|
2020-08-12 11:52:50 +02:00
|
|
|
for (int i = 0; i < length; i++) {
|
|
|
|
if (seen.find(tiles[i].name) != seen.end())
|
|
|
|
continue;
|
|
|
|
seen.insert(tiles[i].name);
|
|
|
|
|
|
|
|
// Load the texture and see if there's any transparent pixels
|
|
|
|
video::ITexture *texture = tsrc->getTexture(tiles[i].name);
|
|
|
|
video::IImage *image = driver->createImage(texture,
|
|
|
|
core::position2d<s32>(0, 0), texture->getOriginalSize());
|
|
|
|
if (!image)
|
|
|
|
continue;
|
|
|
|
core::dimension2d<u32> dim = image->getDimension();
|
|
|
|
bool ok = true;
|
|
|
|
for (u16 x = 0; x < dim.Width; x++) {
|
|
|
|
for (u16 y = 0; y < dim.Height; y++) {
|
|
|
|
if (image->getPixel(x, y).getAlpha() < 255) {
|
|
|
|
ok = false;
|
|
|
|
goto break_loop;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break_loop:
|
|
|
|
image->drop();
|
2021-01-17 01:56:50 +01:00
|
|
|
if (ok)
|
|
|
|
continue;
|
|
|
|
warningstream << "Texture \"" << tiles[i].name << "\" of "
|
|
|
|
<< name << " has transparency, assuming "
|
|
|
|
"use_texture_alpha = \"clip\"." << std::endl;
|
|
|
|
if (!long_warning_printed) {
|
|
|
|
warningstream << " This warning can be a false-positive if "
|
|
|
|
"unused pixels in the texture are transparent. However if "
|
|
|
|
"it is meant to be transparent, you *MUST* update the "
|
|
|
|
"nodedef and set use_texture_alpha = \"clip\"! This "
|
|
|
|
"compatibility code will be removed in a few releases."
|
|
|
|
<< std::endl;
|
|
|
|
long_warning_printed = true;
|
2020-08-12 11:52:50 +02:00
|
|
|
}
|
2021-01-17 01:56:50 +01:00
|
|
|
return true;
|
2020-08-12 11:52:50 +02:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-10-15 09:34:14 +02:00
|
|
|
bool isWorldAligned(AlignStyle style, WorldAlignMode mode, NodeDrawType drawtype)
|
|
|
|
{
|
|
|
|
if (style == ALIGN_STYLE_WORLD)
|
|
|
|
return true;
|
|
|
|
if (mode == WORLDALIGN_DISABLE)
|
|
|
|
return false;
|
|
|
|
if (style == ALIGN_STYLE_USER_DEFINED)
|
|
|
|
return true;
|
|
|
|
if (drawtype == NDT_NORMAL)
|
|
|
|
return mode >= WORLDALIGN_FORCE;
|
|
|
|
if (drawtype == NDT_NODEBOX)
|
|
|
|
return mode >= WORLDALIGN_FORCE_NODEBOX;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-05-22 20:33:06 +02:00
|
|
|
void ContentFeatures::updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc,
|
2017-01-09 20:39:22 +01:00
|
|
|
scene::IMeshManipulator *meshmanip, Client *client, const TextureSettings &tsettings)
|
2016-05-22 20:33:06 +02:00
|
|
|
{
|
|
|
|
// minimap pixel color - the average color of a texture
|
2017-08-19 11:30:46 +02:00
|
|
|
if (tsettings.enable_minimap && !tiledef[0].name.empty())
|
2016-05-22 20:33:06 +02:00
|
|
|
minimap_color = tsrc->getTextureAverageColor(tiledef[0].name);
|
|
|
|
|
|
|
|
// Figure out the actual tiles to use
|
|
|
|
TileDef tdef[6];
|
|
|
|
for (u32 j = 0; j < 6; j++) {
|
|
|
|
tdef[j] = tiledef[j];
|
2017-08-19 11:30:46 +02:00
|
|
|
if (tdef[j].name.empty())
|
2016-05-22 20:33:06 +02:00
|
|
|
tdef[j].name = "unknown_node.png";
|
|
|
|
}
|
2017-05-19 07:46:10 +02:00
|
|
|
// also the overlay tiles
|
|
|
|
TileDef tdef_overlay[6];
|
|
|
|
for (u32 j = 0; j < 6; j++)
|
|
|
|
tdef_overlay[j] = tiledef_overlay[j];
|
|
|
|
// also the special tiles
|
|
|
|
TileDef tdef_spec[6];
|
|
|
|
for (u32 j = 0; j < CF_SPECIAL_COUNT; j++)
|
|
|
|
tdef_spec[j] = tiledef_special[j];
|
2016-05-22 20:33:06 +02:00
|
|
|
|
|
|
|
bool is_liquid = false;
|
|
|
|
|
2021-01-17 01:56:50 +01:00
|
|
|
if (alpha == ALPHAMODE_LEGACY_COMPAT) {
|
|
|
|
// Before working with the alpha mode, resolve any legacy kludges
|
|
|
|
alpha = textureAlphaCheck(tsrc, tdef, 6) ? ALPHAMODE_CLIP : ALPHAMODE_OPAQUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
MaterialType material_type = alpha == ALPHAMODE_OPAQUE ?
|
|
|
|
TILE_MATERIAL_OPAQUE : (alpha == ALPHAMODE_CLIP ? TILE_MATERIAL_BASIC :
|
|
|
|
TILE_MATERIAL_ALPHA);
|
2016-05-22 20:33:06 +02:00
|
|
|
|
|
|
|
switch (drawtype) {
|
|
|
|
default:
|
|
|
|
case NDT_NORMAL:
|
|
|
|
solidness = 2;
|
|
|
|
break;
|
|
|
|
case NDT_AIRLIKE:
|
|
|
|
solidness = 0;
|
|
|
|
break;
|
|
|
|
case NDT_LIQUID:
|
|
|
|
if (tsettings.opaque_water)
|
2021-01-17 01:56:50 +01:00
|
|
|
alpha = ALPHAMODE_OPAQUE;
|
2016-05-22 20:33:06 +02:00
|
|
|
solidness = 1;
|
|
|
|
is_liquid = true;
|
|
|
|
break;
|
|
|
|
case NDT_FLOWINGLIQUID:
|
|
|
|
solidness = 0;
|
|
|
|
if (tsettings.opaque_water)
|
2021-01-17 01:56:50 +01:00
|
|
|
alpha = ALPHAMODE_OPAQUE;
|
2016-05-22 20:33:06 +02:00
|
|
|
is_liquid = true;
|
|
|
|
break;
|
|
|
|
case NDT_GLASSLIKE:
|
|
|
|
solidness = 0;
|
|
|
|
visual_solidness = 1;
|
|
|
|
break;
|
|
|
|
case NDT_GLASSLIKE_FRAMED:
|
|
|
|
solidness = 0;
|
|
|
|
visual_solidness = 1;
|
|
|
|
break;
|
|
|
|
case NDT_GLASSLIKE_FRAMED_OPTIONAL:
|
|
|
|
solidness = 0;
|
|
|
|
visual_solidness = 1;
|
|
|
|
drawtype = tsettings.connected_glass ? NDT_GLASSLIKE_FRAMED : NDT_GLASSLIKE;
|
|
|
|
break;
|
|
|
|
case NDT_ALLFACES:
|
|
|
|
solidness = 0;
|
|
|
|
visual_solidness = 1;
|
|
|
|
break;
|
|
|
|
case NDT_ALLFACES_OPTIONAL:
|
|
|
|
if (tsettings.leaves_style == LEAVES_FANCY) {
|
|
|
|
drawtype = NDT_ALLFACES;
|
|
|
|
solidness = 0;
|
|
|
|
visual_solidness = 1;
|
|
|
|
} else if (tsettings.leaves_style == LEAVES_SIMPLE) {
|
|
|
|
for (u32 j = 0; j < 6; j++) {
|
2017-08-19 11:30:46 +02:00
|
|
|
if (!tdef_spec[j].name.empty())
|
2017-05-19 07:46:10 +02:00
|
|
|
tdef[j].name = tdef_spec[j].name;
|
2016-05-22 20:33:06 +02:00
|
|
|
}
|
|
|
|
drawtype = NDT_GLASSLIKE;
|
|
|
|
solidness = 0;
|
|
|
|
visual_solidness = 1;
|
|
|
|
} else {
|
|
|
|
drawtype = NDT_NORMAL;
|
|
|
|
solidness = 2;
|
2017-08-19 11:30:46 +02:00
|
|
|
for (TileDef &td : tdef)
|
|
|
|
td.name += std::string("^[noalpha");
|
2016-05-22 20:33:06 +02:00
|
|
|
}
|
2017-04-28 20:11:43 +02:00
|
|
|
if (waving >= 1)
|
2016-05-22 20:33:06 +02:00
|
|
|
material_type = TILE_MATERIAL_WAVING_LEAVES;
|
|
|
|
break;
|
|
|
|
case NDT_PLANTLIKE:
|
|
|
|
solidness = 0;
|
2017-04-28 20:11:43 +02:00
|
|
|
if (waving >= 1)
|
2016-05-22 20:33:06 +02:00
|
|
|
material_type = TILE_MATERIAL_WAVING_PLANTS;
|
|
|
|
break;
|
|
|
|
case NDT_FIRELIKE:
|
|
|
|
solidness = 0;
|
|
|
|
break;
|
|
|
|
case NDT_MESH:
|
2017-04-28 20:11:43 +02:00
|
|
|
case NDT_NODEBOX:
|
2016-05-22 20:33:06 +02:00
|
|
|
solidness = 0;
|
2021-01-17 01:56:50 +01:00
|
|
|
if (waving == 1) {
|
2017-04-28 20:11:43 +02:00
|
|
|
material_type = TILE_MATERIAL_WAVING_PLANTS;
|
2021-01-17 01:56:50 +01:00
|
|
|
} else if (waving == 2) {
|
2017-04-28 20:11:43 +02:00
|
|
|
material_type = TILE_MATERIAL_WAVING_LEAVES;
|
2021-01-17 01:56:50 +01:00
|
|
|
} else if (waving == 3) {
|
|
|
|
material_type = alpha == ALPHAMODE_OPAQUE ?
|
|
|
|
TILE_MATERIAL_WAVING_LIQUID_OPAQUE : (alpha == ALPHAMODE_CLIP ?
|
|
|
|
TILE_MATERIAL_WAVING_LIQUID_BASIC : TILE_MATERIAL_WAVING_LIQUID_TRANSPARENT);
|
|
|
|
}
|
2016-05-22 20:33:06 +02:00
|
|
|
break;
|
|
|
|
case NDT_TORCHLIKE:
|
|
|
|
case NDT_SIGNLIKE:
|
|
|
|
case NDT_FENCELIKE:
|
|
|
|
case NDT_RAILLIKE:
|
|
|
|
solidness = 0;
|
|
|
|
break;
|
2017-05-11 22:24:12 +02:00
|
|
|
case NDT_PLANTLIKE_ROOTED:
|
|
|
|
solidness = 2;
|
|
|
|
break;
|
2016-05-22 20:33:06 +02:00
|
|
|
}
|
|
|
|
|
2017-05-19 07:46:10 +02:00
|
|
|
if (is_liquid) {
|
2019-03-27 01:18:43 +01:00
|
|
|
if (waving == 3) {
|
2021-01-17 01:56:50 +01:00
|
|
|
material_type = alpha == ALPHAMODE_OPAQUE ?
|
|
|
|
TILE_MATERIAL_WAVING_LIQUID_OPAQUE : (alpha == ALPHAMODE_CLIP ?
|
|
|
|
TILE_MATERIAL_WAVING_LIQUID_BASIC : TILE_MATERIAL_WAVING_LIQUID_TRANSPARENT);
|
2019-03-27 01:18:43 +01:00
|
|
|
} else {
|
2021-01-17 01:56:50 +01:00
|
|
|
material_type = alpha == ALPHAMODE_OPAQUE ? TILE_MATERIAL_LIQUID_OPAQUE :
|
2019-03-27 01:18:43 +01:00
|
|
|
TILE_MATERIAL_LIQUID_TRANSPARENT;
|
|
|
|
}
|
2017-05-19 07:46:10 +02:00
|
|
|
}
|
2017-01-12 15:46:30 +01:00
|
|
|
|
2017-05-11 22:24:12 +02:00
|
|
|
u32 tile_shader = shdsrc->getShader("nodes_shader", material_type, drawtype);
|
|
|
|
|
2020-12-19 20:57:10 +01:00
|
|
|
MaterialType overlay_material = material_type;
|
2017-06-07 19:52:38 +02:00
|
|
|
if (overlay_material == TILE_MATERIAL_OPAQUE)
|
|
|
|
overlay_material = TILE_MATERIAL_BASIC;
|
|
|
|
else if (overlay_material == TILE_MATERIAL_LIQUID_OPAQUE)
|
|
|
|
overlay_material = TILE_MATERIAL_LIQUID_TRANSPARENT;
|
2017-05-11 22:24:12 +02:00
|
|
|
|
|
|
|
u32 overlay_shader = shdsrc->getShader("nodes_shader", overlay_material, drawtype);
|
2016-05-22 20:33:06 +02:00
|
|
|
|
|
|
|
// Tiles (fill in f->tiles[])
|
|
|
|
for (u16 j = 0; j < 6; j++) {
|
2017-10-15 09:34:14 +02:00
|
|
|
tiles[j].world_aligned = isWorldAligned(tdef[j].align_style,
|
|
|
|
tsettings.world_aligned_mode, drawtype);
|
|
|
|
fillTileAttribs(tsrc, &tiles[j].layers[0], tiles[j], tdef[j],
|
|
|
|
color, material_type, tile_shader,
|
|
|
|
tdef[j].backface_culling, tsettings);
|
2017-08-19 11:30:46 +02:00
|
|
|
if (!tdef_overlay[j].name.empty())
|
2017-10-15 09:34:14 +02:00
|
|
|
fillTileAttribs(tsrc, &tiles[j].layers[1], tiles[j], tdef_overlay[j],
|
|
|
|
color, overlay_material, overlay_shader,
|
|
|
|
tdef[j].backface_culling, tsettings);
|
2016-05-22 20:33:06 +02:00
|
|
|
}
|
|
|
|
|
2020-12-19 20:57:10 +01:00
|
|
|
MaterialType special_material = material_type;
|
2017-05-11 22:24:12 +02:00
|
|
|
if (drawtype == NDT_PLANTLIKE_ROOTED) {
|
|
|
|
if (waving == 1)
|
|
|
|
special_material = TILE_MATERIAL_WAVING_PLANTS;
|
|
|
|
else if (waving == 2)
|
|
|
|
special_material = TILE_MATERIAL_WAVING_LEAVES;
|
|
|
|
}
|
|
|
|
u32 special_shader = shdsrc->getShader("nodes_shader", special_material, drawtype);
|
|
|
|
|
2016-05-22 20:33:06 +02:00
|
|
|
// Special tiles (fill in f->special_tiles[])
|
2017-10-15 09:34:14 +02:00
|
|
|
for (u16 j = 0; j < CF_SPECIAL_COUNT; j++)
|
|
|
|
fillTileAttribs(tsrc, &special_tiles[j].layers[0], special_tiles[j], tdef_spec[j],
|
|
|
|
color, special_material, special_shader,
|
|
|
|
tdef_spec[j].backface_culling, tsettings);
|
2016-05-22 20:33:06 +02:00
|
|
|
|
2017-04-13 01:24:00 +02:00
|
|
|
if (param_type_2 == CPT2_COLOR ||
|
|
|
|
param_type_2 == CPT2_COLORED_FACEDIR ||
|
|
|
|
param_type_2 == CPT2_COLORED_WALLMOUNTED)
|
|
|
|
palette = tsrc->getPalette(palette_name);
|
2017-03-10 18:25:58 +01:00
|
|
|
|
2017-08-19 11:30:46 +02:00
|
|
|
if (drawtype == NDT_MESH && !mesh.empty()) {
|
2016-05-22 20:33:06 +02:00
|
|
|
// Meshnode drawtype
|
|
|
|
// Read the mesh and apply scale
|
2017-01-09 20:39:22 +01:00
|
|
|
mesh_ptr[0] = client->getMesh(mesh);
|
2016-05-22 20:33:06 +02:00
|
|
|
if (mesh_ptr[0]){
|
|
|
|
v3f scale = v3f(1.0, 1.0, 1.0) * BS * visual_scale;
|
|
|
|
scaleMesh(mesh_ptr[0], scale);
|
|
|
|
recalculateBoundingBox(mesh_ptr[0]);
|
|
|
|
meshmanip->recalculateNormals(mesh_ptr[0], true, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Cache 6dfacedir and wallmounted rotated clones of meshes
|
2017-01-12 15:46:30 +01:00
|
|
|
if (tsettings.enable_mesh_cache && mesh_ptr[0] &&
|
|
|
|
(param_type_2 == CPT2_FACEDIR
|
|
|
|
|| param_type_2 == CPT2_COLORED_FACEDIR)) {
|
2016-05-22 20:33:06 +02:00
|
|
|
for (u16 j = 1; j < 24; j++) {
|
|
|
|
mesh_ptr[j] = cloneMesh(mesh_ptr[0]);
|
|
|
|
rotateMeshBy6dFacedir(mesh_ptr[j], j);
|
|
|
|
recalculateBoundingBox(mesh_ptr[j]);
|
|
|
|
meshmanip->recalculateNormals(mesh_ptr[j], true, false);
|
|
|
|
}
|
2017-01-12 15:46:30 +01:00
|
|
|
} else if (tsettings.enable_mesh_cache && mesh_ptr[0]
|
|
|
|
&& (param_type_2 == CPT2_WALLMOUNTED ||
|
|
|
|
param_type_2 == CPT2_COLORED_WALLMOUNTED)) {
|
|
|
|
static const u8 wm_to_6d[6] = { 20, 0, 16 + 1, 12 + 3, 8, 4 + 2 };
|
2016-05-22 20:33:06 +02:00
|
|
|
for (u16 j = 1; j < 6; j++) {
|
|
|
|
mesh_ptr[j] = cloneMesh(mesh_ptr[0]);
|
|
|
|
rotateMeshBy6dFacedir(mesh_ptr[j], wm_to_6d[j]);
|
|
|
|
recalculateBoundingBox(mesh_ptr[j]);
|
|
|
|
meshmanip->recalculateNormals(mesh_ptr[j], true, false);
|
|
|
|
}
|
|
|
|
rotateMeshBy6dFacedir(mesh_ptr[0], wm_to_6d[0]);
|
|
|
|
recalculateBoundingBox(mesh_ptr[0]);
|
|
|
|
meshmanip->recalculateNormals(mesh_ptr[0], true, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-11-15 21:41:49 +01:00
|
|
|
/*
|
2018-02-10 21:04:16 +01:00
|
|
|
NodeDefManager
|
2011-11-15 21:41:49 +01:00
|
|
|
*/
|
|
|
|
|
2017-01-04 19:18:40 +01:00
|
|
|
|
2014-10-03 09:16:43 +02:00
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
NodeDefManager::NodeDefManager()
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
|
|
|
clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
NodeDefManager::~NodeDefManager()
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
2014-10-21 05:12:15 +02:00
|
|
|
#ifndef SERVER
|
2017-08-19 11:30:46 +02:00
|
|
|
for (ContentFeatures &f : m_content_features) {
|
|
|
|
for (auto &j : f.mesh_ptr) {
|
|
|
|
if (j)
|
|
|
|
j->drop();
|
2014-10-21 05:12:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2014-10-03 09:16:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::clear()
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
|
|
|
m_content_features.clear();
|
|
|
|
m_name_id_mapping.clear();
|
|
|
|
m_name_id_mapping_with_aliases.clear();
|
|
|
|
m_group_to_items.clear();
|
|
|
|
m_next_id = 0;
|
2017-01-04 19:18:40 +01:00
|
|
|
m_selection_box_union.reset(0,0,0);
|
|
|
|
m_selection_box_int_union.reset(0,0,0);
|
2014-10-03 09:16:43 +02:00
|
|
|
|
2015-05-05 22:52:06 +02:00
|
|
|
resetNodeResolveState();
|
2015-01-05 04:39:57 +01:00
|
|
|
|
2014-10-03 09:16:43 +02:00
|
|
|
u32 initial_length = 0;
|
|
|
|
initial_length = MYMAX(initial_length, CONTENT_UNKNOWN + 1);
|
|
|
|
initial_length = MYMAX(initial_length, CONTENT_AIR + 1);
|
|
|
|
initial_length = MYMAX(initial_length, CONTENT_IGNORE + 1);
|
|
|
|
m_content_features.resize(initial_length);
|
|
|
|
|
|
|
|
// Set CONTENT_UNKNOWN
|
2011-11-14 20:41:30 +01:00
|
|
|
{
|
2014-10-03 09:16:43 +02:00
|
|
|
ContentFeatures f;
|
|
|
|
f.name = "unknown";
|
|
|
|
// Insert directly into containers
|
|
|
|
content_t c = CONTENT_UNKNOWN;
|
|
|
|
m_content_features[c] = f;
|
|
|
|
addNameIdMapping(c, f.name);
|
2011-11-14 20:41:30 +01:00
|
|
|
}
|
2014-10-03 09:16:43 +02:00
|
|
|
|
|
|
|
// Set CONTENT_AIR
|
2011-11-14 20:41:30 +01:00
|
|
|
{
|
2014-10-03 09:16:43 +02:00
|
|
|
ContentFeatures f;
|
|
|
|
f.name = "air";
|
|
|
|
f.drawtype = NDT_AIRLIKE;
|
|
|
|
f.param_type = CPT_LIGHT;
|
|
|
|
f.light_propagates = true;
|
|
|
|
f.sunlight_propagates = true;
|
|
|
|
f.walkable = false;
|
|
|
|
f.pointable = false;
|
|
|
|
f.diggable = false;
|
|
|
|
f.buildable_to = true;
|
2015-12-30 05:22:58 +01:00
|
|
|
f.floodable = true;
|
2014-10-03 09:16:43 +02:00
|
|
|
f.is_ground_content = true;
|
|
|
|
// Insert directly into containers
|
|
|
|
content_t c = CONTENT_AIR;
|
|
|
|
m_content_features[c] = f;
|
|
|
|
addNameIdMapping(c, f.name);
|
2011-11-14 20:41:30 +01:00
|
|
|
}
|
2014-10-03 09:16:43 +02:00
|
|
|
|
|
|
|
// Set CONTENT_IGNORE
|
2011-11-16 12:03:28 +01:00
|
|
|
{
|
2014-10-03 09:16:43 +02:00
|
|
|
ContentFeatures f;
|
|
|
|
f.name = "ignore";
|
|
|
|
f.drawtype = NDT_AIRLIKE;
|
|
|
|
f.param_type = CPT_NONE;
|
|
|
|
f.light_propagates = false;
|
|
|
|
f.sunlight_propagates = false;
|
|
|
|
f.walkable = false;
|
|
|
|
f.pointable = false;
|
|
|
|
f.diggable = false;
|
|
|
|
f.buildable_to = true; // A way to remove accidental CONTENT_IGNOREs
|
|
|
|
f.is_ground_content = true;
|
|
|
|
// Insert directly into containers
|
|
|
|
content_t c = CONTENT_IGNORE;
|
|
|
|
m_content_features[c] = f;
|
|
|
|
addNameIdMapping(c, f.name);
|
2011-11-16 12:03:28 +01:00
|
|
|
}
|
2014-10-03 09:16:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
bool NodeDefManager::getId(const std::string &name, content_t &result) const
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
2017-06-04 21:00:04 +02:00
|
|
|
std::unordered_map<std::string, content_t>::const_iterator
|
2014-10-03 09:16:43 +02:00
|
|
|
i = m_name_id_mapping_with_aliases.find(name);
|
|
|
|
if(i == m_name_id_mapping_with_aliases.end())
|
|
|
|
return false;
|
|
|
|
result = i->second;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
content_t NodeDefManager::getId(const std::string &name) const
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
|
|
|
content_t id = CONTENT_IGNORE;
|
|
|
|
getId(name, id);
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
bool NodeDefManager::getIds(const std::string &name,
|
2017-09-11 15:51:40 +02:00
|
|
|
std::vector<content_t> &result) const
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
|
|
|
//TimeTaker t("getIds", NULL, PRECISION_MICRO);
|
|
|
|
if (name.substr(0,6) != "group:") {
|
2011-11-19 17:48:09 +01:00
|
|
|
content_t id = CONTENT_IGNORE;
|
2016-02-09 07:08:31 +01:00
|
|
|
bool exists = getId(name, id);
|
|
|
|
if (exists)
|
2017-09-11 15:51:40 +02:00
|
|
|
result.push_back(id);
|
2016-02-09 07:08:31 +01:00
|
|
|
return exists;
|
2011-11-19 17:48:09 +01:00
|
|
|
}
|
2014-10-03 09:16:43 +02:00
|
|
|
std::string group = name.substr(6);
|
|
|
|
|
2017-09-11 15:51:40 +02:00
|
|
|
std::unordered_map<std::string, std::vector<content_t>>::const_iterator
|
2014-10-03 09:16:43 +02:00
|
|
|
i = m_group_to_items.find(group);
|
|
|
|
if (i == m_group_to_items.end())
|
2016-02-09 07:08:31 +01:00
|
|
|
return true;
|
2014-10-03 09:16:43 +02:00
|
|
|
|
2017-09-11 15:51:40 +02:00
|
|
|
const std::vector<content_t> &items = i->second;
|
|
|
|
result.insert(result.end(), items.begin(), items.end());
|
2014-10-03 09:16:43 +02:00
|
|
|
//printf("getIds: %dus\n", t.stop());
|
2016-02-09 07:08:31 +01:00
|
|
|
return true;
|
2014-10-03 09:16:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
const ContentFeatures& NodeDefManager::get(const std::string &name) const
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
|
|
|
content_t id = CONTENT_UNKNOWN;
|
|
|
|
getId(name, id);
|
|
|
|
return get(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// returns CONTENT_IGNORE if no free ID found
|
2018-02-10 21:04:16 +01:00
|
|
|
content_t NodeDefManager::allocateId()
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
|
|
|
for (content_t id = m_next_id;
|
|
|
|
id >= m_next_id; // overflow?
|
|
|
|
++id) {
|
|
|
|
while (id >= m_content_features.size()) {
|
2017-08-19 11:30:46 +02:00
|
|
|
m_content_features.emplace_back();
|
2012-03-31 11:30:11 +02:00
|
|
|
}
|
2014-10-03 09:16:43 +02:00
|
|
|
const ContentFeatures &f = m_content_features[id];
|
2017-08-19 11:30:46 +02:00
|
|
|
if (f.name.empty()) {
|
2014-10-03 09:16:43 +02:00
|
|
|
m_next_id = id + 1;
|
|
|
|
return id;
|
2013-03-31 00:12:23 +01:00
|
|
|
}
|
2011-11-16 13:36:33 +01:00
|
|
|
}
|
2014-10-03 09:16:43 +02:00
|
|
|
// If we arrive here, an overflow occurred in id.
|
|
|
|
// That means no ID was found
|
|
|
|
return CONTENT_IGNORE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-04 19:18:40 +01:00
|
|
|
/*!
|
|
|
|
* Returns the smallest box that contains all boxes
|
|
|
|
* in the vector. Box_union is expanded.
|
|
|
|
* @param[in] boxes the vector containing the boxes
|
|
|
|
* @param[in, out] box_union the union of the arguments
|
|
|
|
*/
|
|
|
|
void boxVectorUnion(const std::vector<aabb3f> &boxes, aabb3f *box_union)
|
|
|
|
{
|
2017-08-19 11:30:46 +02:00
|
|
|
for (const aabb3f &box : boxes) {
|
|
|
|
box_union->addInternalBox(box);
|
2017-01-04 19:18:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* Returns a box that contains the nodebox in every case.
|
|
|
|
* The argument node_union is expanded.
|
|
|
|
* @param[in] nodebox the nodebox to be measured
|
|
|
|
* @param[in] features used to decide whether the nodebox
|
|
|
|
* can be rotated
|
|
|
|
* @param[in, out] box_union the union of the arguments
|
|
|
|
*/
|
|
|
|
void getNodeBoxUnion(const NodeBox &nodebox, const ContentFeatures &features,
|
|
|
|
aabb3f *box_union)
|
|
|
|
{
|
|
|
|
switch(nodebox.type) {
|
|
|
|
case NODEBOX_FIXED:
|
|
|
|
case NODEBOX_LEVELED: {
|
|
|
|
// Raw union
|
|
|
|
aabb3f half_processed(0, 0, 0, 0, 0, 0);
|
|
|
|
boxVectorUnion(nodebox.fixed, &half_processed);
|
|
|
|
// Set leveled boxes to maximal
|
|
|
|
if (nodebox.type == NODEBOX_LEVELED) {
|
|
|
|
half_processed.MaxEdge.Y = +BS / 2;
|
|
|
|
}
|
2017-01-12 15:46:30 +01:00
|
|
|
if (features.param_type_2 == CPT2_FACEDIR ||
|
|
|
|
features.param_type_2 == CPT2_COLORED_FACEDIR) {
|
2017-01-04 19:18:40 +01:00
|
|
|
// Get maximal coordinate
|
|
|
|
f32 coords[] = {
|
|
|
|
fabsf(half_processed.MinEdge.X),
|
|
|
|
fabsf(half_processed.MinEdge.Y),
|
|
|
|
fabsf(half_processed.MinEdge.Z),
|
|
|
|
fabsf(half_processed.MaxEdge.X),
|
|
|
|
fabsf(half_processed.MaxEdge.Y),
|
|
|
|
fabsf(half_processed.MaxEdge.Z) };
|
|
|
|
f32 max = 0;
|
2017-08-19 11:30:46 +02:00
|
|
|
for (float coord : coords) {
|
|
|
|
if (max < coord) {
|
|
|
|
max = coord;
|
2017-01-04 19:18:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Add the union of all possible rotated boxes
|
|
|
|
box_union->addInternalPoint(-max, -max, -max);
|
|
|
|
box_union->addInternalPoint(+max, +max, +max);
|
|
|
|
} else {
|
|
|
|
box_union->addInternalBox(half_processed);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case NODEBOX_WALLMOUNTED: {
|
|
|
|
// Add fix boxes
|
|
|
|
box_union->addInternalBox(nodebox.wall_top);
|
|
|
|
box_union->addInternalBox(nodebox.wall_bottom);
|
|
|
|
// Find maximal coordinate in the X-Z plane
|
|
|
|
f32 coords[] = {
|
|
|
|
fabsf(nodebox.wall_side.MinEdge.X),
|
|
|
|
fabsf(nodebox.wall_side.MinEdge.Z),
|
|
|
|
fabsf(nodebox.wall_side.MaxEdge.X),
|
|
|
|
fabsf(nodebox.wall_side.MaxEdge.Z) };
|
|
|
|
f32 max = 0;
|
2017-08-19 11:30:46 +02:00
|
|
|
for (float coord : coords) {
|
|
|
|
if (max < coord) {
|
|
|
|
max = coord;
|
2017-01-04 19:18:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Add the union of all possible rotated boxes
|
|
|
|
box_union->addInternalPoint(-max, nodebox.wall_side.MinEdge.Y, -max);
|
|
|
|
box_union->addInternalPoint(max, nodebox.wall_side.MaxEdge.Y, max);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case NODEBOX_CONNECTED: {
|
|
|
|
// Add all possible connected boxes
|
2017-04-22 21:17:46 +02:00
|
|
|
boxVectorUnion(nodebox.fixed, box_union);
|
|
|
|
boxVectorUnion(nodebox.connect_top, box_union);
|
|
|
|
boxVectorUnion(nodebox.connect_bottom, box_union);
|
|
|
|
boxVectorUnion(nodebox.connect_front, box_union);
|
|
|
|
boxVectorUnion(nodebox.connect_left, box_union);
|
|
|
|
boxVectorUnion(nodebox.connect_back, box_union);
|
|
|
|
boxVectorUnion(nodebox.connect_right, box_union);
|
|
|
|
boxVectorUnion(nodebox.disconnected_top, box_union);
|
|
|
|
boxVectorUnion(nodebox.disconnected_bottom, box_union);
|
|
|
|
boxVectorUnion(nodebox.disconnected_front, box_union);
|
|
|
|
boxVectorUnion(nodebox.disconnected_left, box_union);
|
|
|
|
boxVectorUnion(nodebox.disconnected_back, box_union);
|
|
|
|
boxVectorUnion(nodebox.disconnected_right, box_union);
|
|
|
|
boxVectorUnion(nodebox.disconnected, box_union);
|
|
|
|
boxVectorUnion(nodebox.disconnected_sides, box_union);
|
2017-01-04 19:18:40 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: {
|
|
|
|
// NODEBOX_REGULAR
|
|
|
|
box_union->addInternalPoint(-BS / 2, -BS / 2, -BS / 2);
|
|
|
|
box_union->addInternalPoint(+BS / 2, +BS / 2, +BS / 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
inline void NodeDefManager::fixSelectionBoxIntUnion()
|
2017-01-04 19:18:40 +01:00
|
|
|
{
|
|
|
|
m_selection_box_int_union.MinEdge.X = floorf(
|
|
|
|
m_selection_box_union.MinEdge.X / BS + 0.5f);
|
|
|
|
m_selection_box_int_union.MinEdge.Y = floorf(
|
|
|
|
m_selection_box_union.MinEdge.Y / BS + 0.5f);
|
|
|
|
m_selection_box_int_union.MinEdge.Z = floorf(
|
|
|
|
m_selection_box_union.MinEdge.Z / BS + 0.5f);
|
|
|
|
m_selection_box_int_union.MaxEdge.X = ceilf(
|
|
|
|
m_selection_box_union.MaxEdge.X / BS - 0.5f);
|
|
|
|
m_selection_box_int_union.MaxEdge.Y = ceilf(
|
|
|
|
m_selection_box_union.MaxEdge.Y / BS - 0.5f);
|
|
|
|
m_selection_box_int_union.MaxEdge.Z = ceilf(
|
|
|
|
m_selection_box_union.MaxEdge.Z / BS - 0.5f);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-08-12 19:18:52 +02:00
|
|
|
void NodeDefManager::eraseIdFromGroups(content_t id)
|
|
|
|
{
|
|
|
|
// For all groups in m_group_to_items...
|
|
|
|
for (auto iter_groups = m_group_to_items.begin();
|
|
|
|
iter_groups != m_group_to_items.end();) {
|
|
|
|
// Get the group items vector.
|
|
|
|
std::vector<content_t> &items = iter_groups->second;
|
|
|
|
|
|
|
|
// Remove any occurence of the id in the group items vector.
|
|
|
|
items.erase(std::remove(items.begin(), items.end(), id), items.end());
|
|
|
|
|
|
|
|
// If group is empty, erase its vector from the map.
|
|
|
|
if (items.empty())
|
|
|
|
iter_groups = m_group_to_items.erase(iter_groups);
|
|
|
|
else
|
|
|
|
++iter_groups;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-10-03 09:16:43 +02:00
|
|
|
// IWritableNodeDefManager
|
2018-02-10 21:04:16 +01:00
|
|
|
content_t NodeDefManager::set(const std::string &name, const ContentFeatures &def)
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
2015-03-06 11:21:51 +01:00
|
|
|
// Pre-conditions
|
2014-10-03 09:16:43 +02:00
|
|
|
assert(name != "");
|
2018-05-20 14:51:50 +02:00
|
|
|
assert(name != "ignore");
|
2014-10-03 09:16:43 +02:00
|
|
|
assert(name == def.name);
|
|
|
|
|
|
|
|
content_t id = CONTENT_IGNORE;
|
|
|
|
if (!m_name_id_mapping.getId(name, id)) { // ignore aliases
|
|
|
|
// Get new id
|
|
|
|
id = allocateId();
|
|
|
|
if (id == CONTENT_IGNORE) {
|
2015-10-14 07:26:03 +02:00
|
|
|
warningstream << "NodeDefManager: Absolute "
|
2014-10-03 09:16:43 +02:00
|
|
|
"limit reached" << std::endl;
|
2013-07-14 00:55:47 +02:00
|
|
|
return CONTENT_IGNORE;
|
2011-11-25 21:45:55 +01:00
|
|
|
}
|
2014-10-03 09:16:43 +02:00
|
|
|
assert(id != CONTENT_IGNORE);
|
|
|
|
addNameIdMapping(id, name);
|
|
|
|
}
|
2019-08-12 19:18:52 +02:00
|
|
|
|
|
|
|
// If there is already ContentFeatures registered for this id, clear old groups
|
|
|
|
if (id < m_content_features.size())
|
|
|
|
eraseIdFromGroups(id);
|
|
|
|
|
2014-10-03 09:16:43 +02:00
|
|
|
m_content_features[id] = def;
|
|
|
|
verbosestream << "NodeDefManager: registering content id \"" << id
|
|
|
|
<< "\": name=\"" << def.name << "\""<<std::endl;
|
2013-07-14 00:55:47 +02:00
|
|
|
|
2017-01-04 19:18:40 +01:00
|
|
|
getNodeBoxUnion(def.selection_box, def, &m_selection_box_union);
|
|
|
|
fixSelectionBoxIntUnion();
|
2019-08-12 19:18:52 +02:00
|
|
|
|
2014-10-03 09:16:43 +02:00
|
|
|
// Add this content to the list of all groups it belongs to
|
2017-08-19 11:30:46 +02:00
|
|
|
for (const auto &group : def.groups) {
|
|
|
|
const std::string &group_name = group.first;
|
2017-09-11 15:51:40 +02:00
|
|
|
m_group_to_items[group_name].push_back(id);
|
2011-11-16 12:03:28 +01:00
|
|
|
}
|
2019-08-12 19:18:52 +02:00
|
|
|
|
2014-10-03 09:16:43 +02:00
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
content_t NodeDefManager::allocateDummy(const std::string &name)
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
2015-03-06 11:21:51 +01:00
|
|
|
assert(name != ""); // Pre-condition
|
2014-10-03 09:16:43 +02:00
|
|
|
ContentFeatures f;
|
|
|
|
f.name = name;
|
|
|
|
return set(name, f);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::removeNode(const std::string &name)
|
2016-07-10 15:15:43 +02:00
|
|
|
{
|
|
|
|
// Pre-condition
|
|
|
|
assert(name != "");
|
|
|
|
|
|
|
|
// Erase name from name ID mapping
|
|
|
|
content_t id = CONTENT_IGNORE;
|
|
|
|
if (m_name_id_mapping.getId(name, id)) {
|
|
|
|
m_name_id_mapping.eraseName(name);
|
|
|
|
m_name_id_mapping_with_aliases.erase(name);
|
|
|
|
}
|
|
|
|
|
2019-08-12 19:18:52 +02:00
|
|
|
eraseIdFromGroups(id);
|
2016-07-10 15:15:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::updateAliases(IItemDefManager *idef)
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
2017-03-22 21:41:02 +01:00
|
|
|
std::set<std::string> all;
|
|
|
|
idef->getAll(all);
|
2014-10-03 09:16:43 +02:00
|
|
|
m_name_id_mapping_with_aliases.clear();
|
2017-08-19 11:30:46 +02:00
|
|
|
for (const std::string &name : all) {
|
2017-03-22 21:41:02 +01:00
|
|
|
const std::string &convert_to = idef->getAlias(name);
|
2014-10-03 09:16:43 +02:00
|
|
|
content_t id;
|
|
|
|
if (m_name_id_mapping.getId(convert_to, id)) {
|
|
|
|
m_name_id_mapping_with_aliases.insert(
|
2015-03-30 12:55:29 +02:00
|
|
|
std::make_pair(name, id));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-14 20:41:29 +02:00
|
|
|
void NodeDefManager::applyTextureOverrides(const std::vector<TextureOverride> &overrides)
|
2015-03-30 12:55:29 +02:00
|
|
|
{
|
2018-02-10 21:04:16 +01:00
|
|
|
infostream << "NodeDefManager::applyTextureOverrides(): Applying "
|
2020-04-14 20:41:29 +02:00
|
|
|
"overrides to textures" << std::endl;
|
2015-03-30 12:55:29 +02:00
|
|
|
|
2020-04-14 20:41:29 +02:00
|
|
|
for (const TextureOverride& texture_override : overrides) {
|
2015-03-30 12:55:29 +02:00
|
|
|
content_t id;
|
2020-04-14 20:41:29 +02:00
|
|
|
if (!getId(texture_override.id, id))
|
2016-07-17 22:26:23 +02:00
|
|
|
continue; // Ignore unknown node
|
2015-03-30 12:55:29 +02:00
|
|
|
|
|
|
|
ContentFeatures &nodedef = m_content_features[id];
|
|
|
|
|
2020-08-04 20:12:47 +02:00
|
|
|
// Override tiles
|
2020-04-14 20:41:29 +02:00
|
|
|
if (texture_override.hasTarget(OverrideTarget::TOP))
|
|
|
|
nodedef.tiledef[0].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::BOTTOM))
|
|
|
|
nodedef.tiledef[1].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::RIGHT))
|
|
|
|
nodedef.tiledef[2].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::LEFT))
|
|
|
|
nodedef.tiledef[3].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::BACK))
|
|
|
|
nodedef.tiledef[4].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::FRONT))
|
|
|
|
nodedef.tiledef[5].name = texture_override.texture;
|
2020-08-04 20:12:47 +02:00
|
|
|
|
|
|
|
|
|
|
|
// Override special tiles, if applicable
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::SPECIAL_1))
|
|
|
|
nodedef.tiledef_special[0].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::SPECIAL_2))
|
|
|
|
nodedef.tiledef_special[1].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::SPECIAL_3))
|
|
|
|
nodedef.tiledef_special[2].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::SPECIAL_4))
|
|
|
|
nodedef.tiledef_special[3].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::SPECIAL_5))
|
|
|
|
nodedef.tiledef_special[4].name = texture_override.texture;
|
|
|
|
|
|
|
|
if (texture_override.hasTarget(OverrideTarget::SPECIAL_6))
|
|
|
|
nodedef.tiledef_special[5].name = texture_override.texture;
|
2011-12-03 22:50:31 +01:00
|
|
|
}
|
2014-10-03 09:16:43 +02:00
|
|
|
}
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::updateTextures(IGameDef *gamedef,
|
2015-03-15 07:25:22 +01:00
|
|
|
void (*progress_callback)(void *progress_args, u32 progress, u32 max_progress),
|
|
|
|
void *progress_callback_args)
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
2011-11-14 21:07:42 +01:00
|
|
|
#ifndef SERVER
|
2018-02-10 21:04:16 +01:00
|
|
|
infostream << "NodeDefManager::updateTextures(): Updating "
|
2014-10-03 09:16:43 +02:00
|
|
|
"textures in node definitions" << std::endl;
|
2017-01-09 20:39:22 +01:00
|
|
|
|
|
|
|
Client *client = (Client *)gamedef;
|
|
|
|
ITextureSource *tsrc = client->tsrc();
|
|
|
|
IShaderSource *shdsrc = client->getShaderSource();
|
2017-06-26 20:11:17 +02:00
|
|
|
scene::IMeshManipulator *meshmanip =
|
|
|
|
RenderingEngine::get_scene_manager()->getMeshManipulator();
|
2016-05-22 20:33:06 +02:00
|
|
|
TextureSettings tsettings;
|
|
|
|
tsettings.readSettings();
|
2013-12-03 17:21:40 +01:00
|
|
|
|
2015-03-15 07:25:22 +01:00
|
|
|
u32 size = m_content_features.size();
|
|
|
|
|
|
|
|
for (u32 i = 0; i < size; i++) {
|
2017-01-12 15:46:30 +01:00
|
|
|
ContentFeatures *f = &(m_content_features[i]);
|
|
|
|
f->updateTextures(tsrc, shdsrc, meshmanip, client, tsettings);
|
2015-03-15 07:25:22 +01:00
|
|
|
progress_callback(progress_callback_args, i, size);
|
2014-10-03 09:16:43 +02:00
|
|
|
}
|
2011-11-14 21:07:42 +01:00
|
|
|
#endif
|
2014-10-03 09:16:43 +02:00
|
|
|
}
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::serialize(std::ostream &os, u16 protocol_version) const
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
|
|
|
writeU8(os, 1); // version
|
|
|
|
u16 count = 0;
|
|
|
|
std::ostringstream os2(std::ios::binary);
|
|
|
|
for (u32 i = 0; i < m_content_features.size(); i++) {
|
|
|
|
if (i == CONTENT_IGNORE || i == CONTENT_AIR
|
|
|
|
|| i == CONTENT_UNKNOWN)
|
|
|
|
continue;
|
2015-05-05 22:52:06 +02:00
|
|
|
const ContentFeatures *f = &m_content_features[i];
|
2017-08-19 11:30:46 +02:00
|
|
|
if (f->name.empty())
|
2014-10-03 09:16:43 +02:00
|
|
|
continue;
|
|
|
|
writeU16(os2, i);
|
|
|
|
// Wrap it in a string to allow different lengths without
|
|
|
|
// strict version incompatibilities
|
|
|
|
std::ostringstream wrapper_os(std::ios::binary);
|
|
|
|
f->serialize(wrapper_os, protocol_version);
|
2020-09-20 13:12:55 +02:00
|
|
|
os2<<serializeString16(wrapper_os.str());
|
2014-10-03 09:16:43 +02:00
|
|
|
|
2015-03-06 11:21:51 +01:00
|
|
|
// must not overflow
|
|
|
|
u16 next = count + 1;
|
|
|
|
FATAL_ERROR_IF(next < count, "Overflow");
|
2014-10-03 09:16:43 +02:00
|
|
|
count++;
|
2011-11-15 18:58:36 +01:00
|
|
|
}
|
2014-10-03 09:16:43 +02:00
|
|
|
writeU16(os, count);
|
2020-09-20 13:12:55 +02:00
|
|
|
os << serializeString32(os2.str());
|
2014-10-03 09:16:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::deSerialize(std::istream &is)
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
|
|
|
clear();
|
|
|
|
int version = readU8(is);
|
|
|
|
if (version != 1)
|
|
|
|
throw SerializationError("unsupported NodeDefinitionManager version");
|
|
|
|
u16 count = readU16(is);
|
2020-09-20 13:12:55 +02:00
|
|
|
std::istringstream is2(deSerializeString32(is), std::ios::binary);
|
2014-10-03 09:16:43 +02:00
|
|
|
ContentFeatures f;
|
|
|
|
for (u16 n = 0; n < count; n++) {
|
|
|
|
u16 i = readU16(is2);
|
|
|
|
|
|
|
|
// Read it from the string wrapper
|
2020-09-20 13:12:55 +02:00
|
|
|
std::string wrapper = deSerializeString16(is2);
|
2014-10-03 09:16:43 +02:00
|
|
|
std::istringstream wrapper_is(wrapper, std::ios::binary);
|
|
|
|
f.deSerialize(wrapper_is);
|
|
|
|
|
|
|
|
// Check error conditions
|
|
|
|
if (i == CONTENT_IGNORE || i == CONTENT_AIR || i == CONTENT_UNKNOWN) {
|
2015-10-14 07:26:03 +02:00
|
|
|
warningstream << "NodeDefManager::deSerialize(): "
|
2014-10-03 09:16:43 +02:00
|
|
|
"not changing builtin node " << i << std::endl;
|
|
|
|
continue;
|
|
|
|
}
|
2017-08-19 11:30:46 +02:00
|
|
|
if (f.name.empty()) {
|
2015-10-14 07:26:03 +02:00
|
|
|
warningstream << "NodeDefManager::deSerialize(): "
|
2014-10-03 09:16:43 +02:00
|
|
|
"received empty name" << std::endl;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ignore aliases
|
|
|
|
u16 existing_id;
|
|
|
|
if (m_name_id_mapping.getId(f.name, existing_id) && i != existing_id) {
|
2015-10-14 07:26:03 +02:00
|
|
|
warningstream << "NodeDefManager::deSerialize(): "
|
2014-10-03 09:16:43 +02:00
|
|
|
"already defined with different ID: " << f.name << std::endl;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// All is ok, add node definition with the requested ID
|
|
|
|
if (i >= m_content_features.size())
|
|
|
|
m_content_features.resize((u32)(i) + 1);
|
|
|
|
m_content_features[i] = f;
|
|
|
|
addNameIdMapping(i, f.name);
|
2020-04-08 20:13:23 +02:00
|
|
|
TRACESTREAM(<< "NodeDef: deserialized " << f.name << std::endl);
|
2017-01-04 19:18:40 +01:00
|
|
|
|
|
|
|
getNodeBoxUnion(f.selection_box, f, &m_selection_box_union);
|
|
|
|
fixSelectionBoxIntUnion();
|
2012-01-12 06:10:39 +01:00
|
|
|
}
|
2020-05-20 23:52:10 +02:00
|
|
|
|
|
|
|
// Since liquid_alternative_flowing_id and liquid_alternative_source_id
|
|
|
|
// are not sent, resolve them client-side too.
|
|
|
|
resolveCrossrefs();
|
2014-10-03 09:16:43 +02:00
|
|
|
}
|
|
|
|
|
2011-11-14 20:41:30 +01:00
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::addNameIdMapping(content_t i, std::string name)
|
2014-10-03 09:16:43 +02:00
|
|
|
{
|
|
|
|
m_name_id_mapping.set(i, name);
|
|
|
|
m_name_id_mapping_with_aliases.insert(std::make_pair(name, i));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
NodeDefManager *createNodeDefManager()
|
2015-01-04 22:32:31 +01:00
|
|
|
{
|
2018-02-10 21:04:16 +01:00
|
|
|
return new NodeDefManager();
|
2015-01-04 22:32:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::pendNodeResolve(NodeResolver *nr) const
|
2014-10-08 21:28:14 +02:00
|
|
|
{
|
2015-04-16 10:12:26 +02:00
|
|
|
nr->m_ndef = this;
|
2015-05-07 08:34:15 +02:00
|
|
|
if (m_node_registration_complete)
|
2015-04-16 10:12:26 +02:00
|
|
|
nr->nodeResolveInternal();
|
2015-05-07 08:34:15 +02:00
|
|
|
else
|
|
|
|
m_pending_resolve_callbacks.push_back(nr);
|
2014-10-08 21:28:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
bool NodeDefManager::cancelNodeResolveCallback(NodeResolver *nr) const
|
2014-10-08 21:28:14 +02:00
|
|
|
{
|
2015-04-16 10:12:26 +02:00
|
|
|
size_t len = m_pending_resolve_callbacks.size();
|
|
|
|
for (size_t i = 0; i != len; i++) {
|
|
|
|
if (nr != m_pending_resolve_callbacks[i])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
len--;
|
|
|
|
m_pending_resolve_callbacks[i] = m_pending_resolve_callbacks[len];
|
|
|
|
m_pending_resolve_callbacks.resize(len);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::runNodeResolveCallbacks()
|
2015-04-16 10:12:26 +02:00
|
|
|
{
|
|
|
|
for (size_t i = 0; i != m_pending_resolve_callbacks.size(); i++) {
|
|
|
|
NodeResolver *nr = m_pending_resolve_callbacks[i];
|
|
|
|
nr->nodeResolveInternal();
|
2014-10-08 21:28:14 +02:00
|
|
|
}
|
2015-04-16 10:12:26 +02:00
|
|
|
|
|
|
|
m_pending_resolve_callbacks.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
void NodeDefManager::resetNodeResolveState()
|
2015-05-05 22:52:06 +02:00
|
|
|
{
|
|
|
|
m_node_registration_complete = false;
|
|
|
|
m_pending_resolve_callbacks.clear();
|
|
|
|
}
|
|
|
|
|
2020-05-20 23:52:10 +02:00
|
|
|
static void removeDupes(std::vector<content_t> &list)
|
|
|
|
{
|
|
|
|
std::sort(list.begin(), list.end());
|
|
|
|
auto new_end = std::unique(list.begin(), list.end());
|
|
|
|
list.erase(new_end, list.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
void NodeDefManager::resolveCrossrefs()
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
{
|
2017-08-19 11:30:46 +02:00
|
|
|
for (ContentFeatures &f : m_content_features) {
|
2021-01-21 00:51:24 +01:00
|
|
|
if (f.liquid_type != LIQUID_NONE || f.drawtype == NDT_LIQUID || f.drawtype == NDT_FLOWINGLIQUID) {
|
2020-05-20 23:52:10 +02:00
|
|
|
f.liquid_alternative_flowing_id = getId(f.liquid_alternative_flowing);
|
|
|
|
f.liquid_alternative_source_id = getId(f.liquid_alternative_source);
|
|
|
|
continue;
|
|
|
|
}
|
2017-08-19 11:30:46 +02:00
|
|
|
if (f.drawtype != NDT_NODEBOX || f.node_box.type != NODEBOX_CONNECTED)
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
continue;
|
2017-08-19 11:30:46 +02:00
|
|
|
|
2017-09-11 15:51:40 +02:00
|
|
|
for (const std::string &name : f.connects_to) {
|
|
|
|
getIds(name, f.connects_to_ids);
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
}
|
2020-05-20 23:52:10 +02:00
|
|
|
removeDupes(f.connects_to_ids);
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-10 21:04:16 +01:00
|
|
|
bool NodeDefManager::nodeboxConnects(MapNode from, MapNode to,
|
|
|
|
u8 connect_face) const
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
{
|
|
|
|
const ContentFeatures &f1 = get(from);
|
|
|
|
|
|
|
|
if ((f1.drawtype != NDT_NODEBOX) || (f1.node_box.type != NODEBOX_CONNECTED))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// lookup target in connected set
|
2017-09-11 15:51:40 +02:00
|
|
|
if (!CONTAINS(f1.connects_to_ids, to.param0))
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
return false;
|
|
|
|
|
|
|
|
const ContentFeatures &f2 = get(to);
|
|
|
|
|
2016-03-13 22:25:54 +01:00
|
|
|
if ((f2.drawtype == NDT_NODEBOX) && (f2.node_box.type == NODEBOX_CONNECTED))
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
// ignores actually looking if back connection exists
|
2017-09-11 15:51:40 +02:00
|
|
|
return CONTAINS(f2.connects_to_ids, from.param0);
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
|
Allow nodes to specify which sides to connect to.
NDT_CONNECTED attempts to connect to any side of nodes that it can
connect to, which is troublesome for FACEDIR type nodes that generally
may only have one usable face, and can be rotated.
We introduce a node parameter `connect_sides` that is valid for
any node type. If specified, it lists faces of the node (in "top",
"bottom", "front", "left", "back", "right", form, as array) that
connecting nodeboxes can connect to. "front" corresponds to the south
facing side of a node with facedir = 0.
If the node is rotatable using *simple* FACEDIR, then the attached
face is properly rotated before checking. This allows e.g. a chest
to be attached to only from the rear side.
2016-03-04 08:18:04 +01:00
|
|
|
// does to node declare usable faces?
|
|
|
|
if (f2.connect_sides > 0) {
|
2017-01-12 15:46:30 +01:00
|
|
|
if ((f2.param_type_2 == CPT2_FACEDIR ||
|
|
|
|
f2.param_type_2 == CPT2_COLORED_FACEDIR)
|
|
|
|
&& (connect_face >= 4)) {
|
|
|
|
static const u8 rot[33 * 4] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 4, 32, 16, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, // 4 - back
|
|
|
|
8, 4, 32, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, // 8 - right
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 8, 4, 32, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, // 16 - front
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
|
0, 0, 0, 0, 0, 0, 32, 16, 8, 4 // 32 - left
|
|
|
|
};
|
|
|
|
return (f2.connect_sides
|
|
|
|
& rot[(connect_face * 4) + (to.param2 & 0x1F)]);
|
Allow nodes to specify which sides to connect to.
NDT_CONNECTED attempts to connect to any side of nodes that it can
connect to, which is troublesome for FACEDIR type nodes that generally
may only have one usable face, and can be rotated.
We introduce a node parameter `connect_sides` that is valid for
any node type. If specified, it lists faces of the node (in "top",
"bottom", "front", "left", "back", "right", form, as array) that
connecting nodeboxes can connect to. "front" corresponds to the south
facing side of a node with facedir = 0.
If the node is rotatable using *simple* FACEDIR, then the attached
face is properly rotated before checking. This allows e.g. a chest
to be attached to only from the rear side.
2016-03-04 08:18:04 +01:00
|
|
|
}
|
|
|
|
return (f2.connect_sides & connect_face);
|
|
|
|
}
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 09:16:31 +01:00
|
|
|
// the target is just a regular node, so connect no matter back connection
|
|
|
|
return true;
|
|
|
|
}
|
2015-05-05 22:52:06 +02:00
|
|
|
|
2015-04-16 10:12:26 +02:00
|
|
|
////
|
|
|
|
//// NodeResolver
|
|
|
|
////
|
|
|
|
|
2015-05-05 17:36:40 +02:00
|
|
|
NodeResolver::NodeResolver()
|
|
|
|
{
|
2015-04-16 10:12:26 +02:00
|
|
|
m_nodenames.reserve(16);
|
|
|
|
m_nnlistsizes.reserve(4);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
NodeResolver::~NodeResolver()
|
|
|
|
{
|
|
|
|
if (!m_resolve_done && m_ndef)
|
|
|
|
m_ndef->cancelNodeResolveCallback(this);
|
2014-10-08 21:28:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-04-09 23:40:12 +02:00
|
|
|
void NodeResolver::cloneTo(NodeResolver *res) const
|
|
|
|
{
|
|
|
|
FATAL_ERROR_IF(!m_resolve_done, "NodeResolver can only be cloned"
|
|
|
|
" after resolving has completed");
|
|
|
|
/* We don't actually do anything significant. Since the node resolving has
|
|
|
|
* already completed, the class that called us will already have the
|
|
|
|
* resolved IDs in its data structures (which it copies on its own) */
|
|
|
|
res->m_ndef = m_ndef;
|
|
|
|
res->m_resolve_done = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-16 10:12:26 +02:00
|
|
|
void NodeResolver::nodeResolveInternal()
|
2014-10-08 21:28:14 +02:00
|
|
|
{
|
2015-04-16 10:12:26 +02:00
|
|
|
m_nodenames_idx = 0;
|
|
|
|
m_nnlistsizes_idx = 0;
|
|
|
|
|
|
|
|
resolveNodeNames();
|
|
|
|
m_resolve_done = true;
|
|
|
|
|
|
|
|
m_nodenames.clear();
|
|
|
|
m_nnlistsizes.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool NodeResolver::getIdFromNrBacklog(content_t *result_out,
|
2018-04-20 21:26:30 +02:00
|
|
|
const std::string &node_alt, content_t c_fallback, bool error_on_fallback)
|
2014-10-08 21:28:14 +02:00
|
|
|
{
|
2015-04-16 10:12:26 +02:00
|
|
|
if (m_nodenames_idx == m_nodenames.size()) {
|
|
|
|
*result_out = c_fallback;
|
2015-05-05 17:36:40 +02:00
|
|
|
errorstream << "NodeResolver: no more nodes in list" << std::endl;
|
2014-12-17 09:20:17 +01:00
|
|
|
return false;
|
2014-10-08 21:28:14 +02:00
|
|
|
}
|
|
|
|
|
2014-12-17 09:20:17 +01:00
|
|
|
content_t c;
|
2015-04-16 10:12:26 +02:00
|
|
|
std::string name = m_nodenames[m_nodenames_idx++];
|
2014-10-08 21:28:14 +02:00
|
|
|
|
2015-04-16 10:12:26 +02:00
|
|
|
bool success = m_ndef->getId(name, c);
|
2017-08-20 19:37:29 +02:00
|
|
|
if (!success && !node_alt.empty()) {
|
2014-12-17 09:20:17 +01:00
|
|
|
name = node_alt;
|
2015-04-16 10:12:26 +02:00
|
|
|
success = m_ndef->getId(name, c);
|
2014-12-17 09:20:17 +01:00
|
|
|
}
|
2014-10-08 21:28:14 +02:00
|
|
|
|
2014-12-17 09:20:17 +01:00
|
|
|
if (!success) {
|
2018-04-20 21:26:30 +02:00
|
|
|
if (error_on_fallback)
|
|
|
|
errorstream << "NodeResolver: failed to resolve node name '" << name
|
|
|
|
<< "'." << std::endl;
|
2014-12-17 09:20:17 +01:00
|
|
|
c = c_fallback;
|
2014-10-08 21:28:14 +02:00
|
|
|
}
|
|
|
|
|
2015-04-16 10:12:26 +02:00
|
|
|
*result_out = c;
|
2014-12-17 09:20:17 +01:00
|
|
|
return success;
|
2014-10-08 21:28:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-16 10:12:26 +02:00
|
|
|
bool NodeResolver::getIdsFromNrBacklog(std::vector<content_t> *result_out,
|
|
|
|
bool all_required, content_t c_fallback)
|
2014-10-08 21:28:14 +02:00
|
|
|
{
|
2014-12-28 04:20:04 +01:00
|
|
|
bool success = true;
|
|
|
|
|
2015-04-16 10:12:26 +02:00
|
|
|
if (m_nnlistsizes_idx == m_nnlistsizes.size()) {
|
|
|
|
errorstream << "NodeResolver: no more node lists" << std::endl;
|
2014-12-17 09:20:17 +01:00
|
|
|
return false;
|
|
|
|
}
|
2014-10-08 21:28:14 +02:00
|
|
|
|
2015-04-16 10:12:26 +02:00
|
|
|
size_t length = m_nnlistsizes[m_nnlistsizes_idx++];
|
2014-10-08 21:28:14 +02:00
|
|
|
|
2015-04-16 10:12:26 +02:00
|
|
|
while (length--) {
|
|
|
|
if (m_nodenames_idx == m_nodenames.size()) {
|
|
|
|
errorstream << "NodeResolver: no more nodes in list" << std::endl;
|
2014-12-17 09:20:17 +01:00
|
|
|
return false;
|
2014-10-08 21:28:14 +02:00
|
|
|
}
|
|
|
|
|
2014-12-17 09:20:17 +01:00
|
|
|
content_t c;
|
2015-04-16 10:12:26 +02:00
|
|
|
std::string &name = m_nodenames[m_nodenames_idx++];
|
2014-12-28 04:20:04 +01:00
|
|
|
|
2014-12-30 05:15:53 +01:00
|
|
|
if (name.substr(0,6) != "group:") {
|
2015-04-16 10:12:26 +02:00
|
|
|
if (m_ndef->getId(name, c)) {
|
|
|
|
result_out->push_back(c);
|
|
|
|
} else if (all_required) {
|
|
|
|
errorstream << "NodeResolver: failed to resolve node name '"
|
|
|
|
<< name << "'." << std::endl;
|
|
|
|
result_out->push_back(c_fallback);
|
2014-12-30 05:15:53 +01:00
|
|
|
success = false;
|
|
|
|
}
|
|
|
|
} else {
|
2017-09-11 15:51:40 +02:00
|
|
|
m_ndef->getIds(name, *result_out);
|
2014-10-08 21:28:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-28 04:20:04 +01:00
|
|
|
return success;
|
2014-10-08 21:28:14 +02:00
|
|
|
}
|