minetest/src/nodedef.h

471 lines
13 KiB
C
Raw Normal View History

/*
2013-02-24 09:40:43 -08:00
Minetest
2013-02-24 10:38:45 -08:00
Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
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
(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
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
2011-11-14 11:41:30 -08:00
#ifndef NODEDEF_HEADER
#define NODEDEF_HEADER
2012-06-16 18:00:31 -07:00
#include "irrlichttypes_bloated.h"
#include <string>
#include <iostream>
2012-02-28 09:45:23 -08:00
#include <map>
2013-03-30 16:12:23 -07:00
#include <list>
#include "mapnode.h"
#ifndef SERVER
#include "tile.h"
#include "shader.h"
#endif
2012-03-04 04:22:35 -08:00
#include "itemgroup.h"
#include "sound.h" // SimpleSoundSpec
#include "constants.h" // BS
class IItemDefManager;
class ITextureSource;
class IShaderSource;
class IGameDef;
2013-03-30 16:12:23 -07:00
typedef std::list<std::pair<content_t, int> > GroupItems;
enum ContentParamType
{
CPT_NONE,
CPT_LIGHT,
};
enum ContentParamType2
{
CPT2_NONE,
// Need 8-bit param2
CPT2_FULL,
// Flowing liquid properties
CPT2_FLOWINGLIQUID,
// Direction for chests and furnaces and such
CPT2_FACEDIR,
// Direction for signs, torches and such
CPT2_WALLMOUNTED,
2013-07-13 10:48:14 -07:00
// Block level like FLOWINGLIQUID
CPT2_LEVELED,
};
enum LiquidType
{
LIQUID_NONE,
LIQUID_FLOWING,
2013-07-13 10:48:14 -07:00
LIQUID_SOURCE,
};
2011-11-13 02:31:05 -08:00
enum NodeBoxType
{
NODEBOX_REGULAR, // Regular block; allows buildable_to
NODEBOX_FIXED, // Static separately defined box(es)
NODEBOX_WALLMOUNTED, // Box for wall mounted nodes; (top, bottom, side)
2013-07-13 10:48:14 -07:00
NODEBOX_LEVELED, // Same as fixed, but with dynamic height from param2. for snow, ...
2011-11-13 02:31:05 -08:00
};
struct NodeBox
{
enum NodeBoxType type;
// NODEBOX_REGULAR (no parameters)
// NODEBOX_FIXED
std::vector<aabb3f> fixed;
2011-11-13 02:31:05 -08:00
// NODEBOX_WALLMOUNTED
aabb3f wall_top;
aabb3f wall_bottom;
aabb3f wall_side; // being at the -X side
2011-11-13 02:31:05 -08:00
NodeBox()
{ reset(); }
void reset();
2013-08-01 13:50:58 -07:00
void serialize(std::ostream &os, u16 protocol_version) const;
void deSerialize(std::istream &is);
2011-11-13 02:31:05 -08:00
};
struct MapNode;
class NodeMetadata;
2012-06-15 17:40:45 -07:00
/*
Stand-alone definition of a TileSpec (basically a server-side TileSpec)
*/
enum TileAnimationType{
TAT_NONE=0,
TAT_VERTICAL_FRAMES=1,
};
struct TileDef
{
2012-06-15 17:40:45 -07:00
std::string name;
bool backface_culling; // Takes effect only in special cases
struct{
enum TileAnimationType type;
int aspect_w; // width for aspect ratio
int aspect_h; // height for aspect ratio
float length; // seconds
} animation;
TileDef()
{
name = "";
backface_culling = true;
animation.type = TAT_NONE;
animation.aspect_w = 1;
animation.aspect_h = 1;
animation.length = 1.0;
}
void serialize(std::ostream &os, u16 protocol_version) const;
void deSerialize(std::istream &is);
};
enum NodeDrawType
{
NDT_NORMAL, // A basic solid block
NDT_AIRLIKE, // Nothing is drawn
NDT_LIQUID, // Do not draw face towards same kind of flowing/source liquid
NDT_FLOWINGLIQUID, // A very special kind of thing
NDT_GLASSLIKE, // Glass-like, don't draw faces towards other glass
NDT_ALLFACES, // Leaves-like, draw all faces no matter what
NDT_ALLFACES_OPTIONAL, // Fancy -> allfaces, fast -> normal
NDT_TORCHLIKE,
NDT_SIGNLIKE,
NDT_PLANTLIKE,
NDT_FENCELIKE,
NDT_RAILLIKE,
NDT_NODEBOX,
NDT_GLASSLIKE_FRAMED, // Glass-like, draw connected frames and all all
// visible faces
// uses 2 textures, one for frames, second for faces
2014-09-27 09:16:26 -07:00
NDT_FIRELIKE, // Draw faces slightly rotated and only on connecting nodes,
NDT_GLASSLIKE_FRAMED_OPTIONAL, // enabled -> connected, disabled -> Glass-like
// uses 2 textures, one for frames, second for faces
2014-10-14 19:13:53 -07:00
NDT_MESH, // Uses static meshes
};
#define CF_SPECIAL_COUNT 6
struct ContentFeatures
{
/*
Cached stuff
*/
#ifndef SERVER
2011-11-15 04:43:15 -08:00
// 0 1 2 3 4 5
// up down right left back front
TileSpec tiles[6];
// Special tiles
2011-11-15 04:43:15 -08:00
// - Currently used for flowing liquids
TileSpec special_tiles[CF_SPECIAL_COUNT];
u8 solidness; // Used when choosing which face is drawn
u8 visual_solidness; // When solidness=0, this tells how it looks like
bool backface_culling;
#endif
// Server-side cached callback existence for fast skipping
bool has_on_construct;
bool has_on_destruct;
bool has_after_destruct;
/*
Actual data
*/
2011-11-15 23:36:19 -08:00
std::string name; // "" = undefined node
2012-03-04 04:22:35 -08:00
ItemGroupList groups; // Same as in itemdef
2011-11-15 23:36:19 -08:00
// Visual definition
enum NodeDrawType drawtype;
2014-10-14 19:13:53 -07:00
std::string mesh;
#ifndef SERVER
scene::IMesh *mesh_ptr[24];
#endif
float visual_scale; // Misc. scale parameter
2012-06-15 17:40:45 -07:00
TileDef tiledef[6];
TileDef tiledef_special[CF_SPECIAL_COUNT]; // eg. flowing liquid
2011-11-15 04:43:15 -08:00
u8 alpha;
// Post effect color, drawn when the camera is inside the node.
video::SColor post_effect_color;
// Type of MapNode::param1
ContentParamType param_type;
// Type of MapNode::param2
ContentParamType2 param_type_2;
// True for all ground-like things like stone and mud, false for eg. trees
bool is_ground_content;
bool light_propagates;
bool sunlight_propagates;
// This is used for collision detection.
// Also for general solidness queries.
bool walkable;
// Player can point to these
bool pointable;
// Player can dig these
bool diggable;
// Player can climb these
bool climbable;
// Player can build on these
bool buildable_to;
// Player cannot build to these (placement prediction disabled)
bool rightclickable;
2013-07-13 10:48:14 -07:00
// Flowing liquid or snow, value = default level
u8 leveled;
// Whether the node is non-liquid, source liquid or flowing liquid
enum LiquidType liquid_type;
// If the content is liquid, this is the flowing version of the liquid.
std::string liquid_alternative_flowing;
// If the content is liquid, this is the source version of the liquid.
std::string liquid_alternative_source;
// Viscosity for fluid flow, ranging from 1 to 7, with
// 1 giving almost instantaneous propagation and 7 being
// the slowest possible
u8 liquid_viscosity;
2012-09-07 09:48:12 -07:00
// Is liquid renewable (new liquid source will be created between 2 existing)
bool liquid_renewable;
2013-07-27 11:34:30 -07:00
// Ice for water, water for ice
std::string freezemelt;
2013-07-16 07:28:18 -07:00
// Number of flowing liquids surrounding source
u8 liquid_range;
u8 drowning;
// Amount of light the node emits
u8 light_source;
u32 damage_per_second;
NodeBox node_box;
2011-11-13 02:31:05 -08:00
NodeBox selection_box;
2014-10-18 09:46:16 -07:00
NodeBox collision_box;
2013-12-03 08:21:40 -08:00
// Used for waving leaves/plants
u8 waving;
// Compatibility with old maps
// Set to true if paramtype used to be 'facedir_simple'
bool legacy_facedir_simple;
// Set to true if wall_mounted used to be set to true
bool legacy_wallmounted;
// Sound properties
SimpleSoundSpec sound_footstep;
2012-03-24 02:10:28 -07:00
SimpleSoundSpec sound_dig;
2012-03-23 18:28:08 -07:00
SimpleSoundSpec sound_dug;
/*
Methods
*/
ContentFeatures();
~ContentFeatures();
void reset();
void serialize(std::ostream &os, u16 protocol_version);
void deSerialize(std::istream &is);
void serializeOld(std::ostream &os, u16 protocol_version);
void deSerializeOld(std::istream &is, int version);
2011-11-14 11:41:30 -08:00
/*
Some handy methods
*/
bool isLiquid() const{
return (liquid_type != LIQUID_NONE);
}
bool sameLiquid(const ContentFeatures &f) const{
if(!isLiquid() || !f.isLiquid()) return false;
return (liquid_alternative_flowing == f.liquid_alternative_flowing);
}
};
struct NodeResolveInfo {
std::string n_wanted;
std::string n_alt;
content_t c_fallback;
content_t *output;
};
#define NR_STATUS_FAILURE 0
#define NR_STATUS_PENDING 1
#define NR_STATUS_SUCCESS 2
/**
NodeResolver
NodeResolver attempts to resolve node names to content ID integers. If the
node registration phase has not yet finished at the time the resolution
request is placed, the request is marked as pending and added to an internal
queue. The name resolution request is later satisfied by writing directly
to the output location when the node registration phase has been completed.
This is primarily intended to be used for objects registered during script
initialization (i.e. while nodes are being registered) that reference
particular nodes.
*/
class NodeResolver {
public:
NodeResolver(INodeDefManager *ndef);
~NodeResolver();
/**
Add a request to resolve the node n_wanted and set *content to the
result, or alternatively, n_alt if n_wanted is not found. If n_alt
cannot be found either, or has not been specified, *content is set
to c_fallback.
If node registration is complete, the request is finished immediately
and NR_STATUS_SUCCESS is returned (or NR_STATUS_FAILURE if no node can
be found). Otherwise, NR_STATUS_PENDING is returned and the resolution
request is queued.
N.B. If the memory in which content is located has been deallocated
before the pending request had been satisfied, cancelNode() must be
called.
@param n_wanted Name of node that is wanted.
@param n_alt Name of node in case n_wanted could not be found. Blank
if no alternative node is desired.
@param c_fallback Content ID that content is set to in case of node
resolution failure (should be CONTENT_AIR, CONTENT_IGNORE, etc.)
@param content Pointer to content_t that receives the result of the
node name resolution.
@return Status of node resolution request.
*/
int addNode(std::string n_wanted, std::string n_alt,
content_t c_fallback, content_t *content);
/**
Add a request to resolve the node(s) specified by nodename.
If node registration is complete, the request is finished immediately
and NR_STATUS_SUCCESS is returned if at least one node is resolved; if
zero were resolved, NR_STATUS_FAILURE. Otherwise, NR_STATUS_PENDING is
returned and the resolution request is queued.
N.B. If the memory in which content_vec is located has been deallocated
before the pending request had been satisfied, cancelNodeList() must be
called.
@param nodename Name of node (or node group) to be resolved.
@param content_vec Pointer to content_t vector onto which the results
are added.
@return Status of node resolution request.
*/
int addNodeList(const char *nodename, std::vector<content_t> *content_vec);
/**
Removes all pending requests from the resolution queue to be satisfied
to content.
@param content Location of the content ID for the request being
cancelled.
@return Number of pending requests cancelled.
*/
bool cancelNode(content_t *content);
/**
Removes all pending requests from the resolution queue to be satisfied
to content_vec.
@param content_vec Location of the content ID vector for requests being
cancelled.
@return Number of pending requests cancelled.
*/
int cancelNodeList(std::vector<content_t> *content_vec);
/**
Carries out all pending node resolution requests. Call this when the
node registration phase has completed.
Internally marks node registration as complete.
@return Number of failed pending requests.
*/
int resolveNodes();
/**
Returns the status of the node registration phase.
@return Boolean of whether the registration phase is complete.
*/
bool isNodeRegFinished() { return m_is_node_registration_complete; }
private:
INodeDefManager *m_ndef;
bool m_is_node_registration_complete;
std::list<NodeResolveInfo *> m_pending_contents;
std::list<std::pair<std::string, std::vector<content_t> *> > m_pending_content_vecs;
};
2011-11-14 11:41:30 -08:00
class INodeDefManager
{
2011-11-14 11:41:30 -08:00
public:
INodeDefManager(){}
virtual ~INodeDefManager(){}
// Get node definition
virtual const ContentFeatures& get(content_t c) const=0;
virtual const ContentFeatures& get(const MapNode &n) const=0;
2011-11-16 03:03:28 -08:00
virtual bool getId(const std::string &name, content_t &result) const=0;
virtual content_t getId(const std::string &name) const=0;
// Allows "group:name" in addition to regular node names
virtual void getIds(const std::string &name, std::set<content_t> &result)
const=0;
virtual const ContentFeatures& get(const std::string &name) const=0;
2011-11-15 10:32:56 -08:00
virtual void serialize(std::ostream &os, u16 protocol_version)=0;
virtual NodeResolver *getResolver()=0;
2011-11-14 11:41:30 -08:00
};
class IWritableNodeDefManager : public INodeDefManager
{
2011-11-14 11:41:30 -08:00
public:
IWritableNodeDefManager(){}
virtual ~IWritableNodeDefManager(){}
virtual IWritableNodeDefManager* clone()=0;
// Get node definition
virtual const ContentFeatures& get(content_t c) const=0;
virtual const ContentFeatures& get(const MapNode &n) const=0;
2011-11-16 03:03:28 -08:00
virtual bool getId(const std::string &name, content_t &result) const=0;
// If not found, returns CONTENT_IGNORE
virtual content_t getId(const std::string &name) const=0;
// Allows "group:name" in addition to regular node names
virtual void getIds(const std::string &name, std::set<content_t> &result)
const=0;
// If not found, returns the features of CONTENT_UNKNOWN
virtual const ContentFeatures& get(const std::string &name) const=0;
2011-11-16 03:03:28 -08:00
// Register node definition by name (allocate an id)
// If returns CONTENT_IGNORE, could not allocate id
virtual content_t set(const std::string &name,
const ContentFeatures &def)=0;
// If returns CONTENT_IGNORE, could not allocate id
virtual content_t allocateDummy(const std::string &name)=0;
/*
Update item alias mapping.
Call after updating item definitions.
*/
virtual void updateAliases(IItemDefManager *idef)=0;
/*
Update tile textures to latest return values of TextueSource.
*/
2014-10-14 19:13:53 -07:00
virtual void updateTextures(IGameDef *gamedef)=0;
virtual void serialize(std::ostream &os, u16 protocol_version)=0;
virtual void deSerialize(std::istream &is)=0;
virtual NodeResolver *getResolver()=0;
2011-11-14 11:41:30 -08:00
};
IWritableNodeDefManager *createNodeDefManager();
#endif