summaryrefslogtreecommitdiff
path: root/src/mapblock_mesh.h
blob: be56d4c586a03e37ac20bcc7120f988073665b68 (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

/*
Minetest
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.
*/

#ifndef MAPBLOCK_MESH_HEADER
#define MAPBLOCK_MESH_HEADER

#include "irrlichttypes_extrabloated.h"
#include "tile.h"
#include "voxel.h"
#include <map>

class IGameDef;

/*
	Mesh making stuff
*/


class MapBlock;

struct MeshMakeData
{
	VoxelManipulator m_vmanip;
	v3s16 m_blockpos;
	v3s16 m_crack_pos_relative;
	v3s16 m_highlighted_pos_relative;
	bool m_smooth_lighting;
	bool m_show_hud;
	video::SColor m_highlight_mesh_color;

	IGameDef *m_gamedef;

	MeshMakeData(IGameDef *gamedef);

	/*
		Copy central data directly from block, and other data from
		parent of block.
	*/
	void fill(MapBlock *block);

	/*
		Set up with only a single node at (1,1,1)
	*/
	void fillSingleNode(MapNode *node);

	/*
		Set the (node) position of a crack
	*/
	void setCrack(int crack_level, v3s16 crack_pos);

	/*
		Set the highlighted node position
	*/

	void setHighlighted(v3s16 highlighted_pos, bool show_hud);
	/*
		Enable or disable smooth lighting
	*/
	void setSmoothLighting(bool smooth_lighting);
};

/*
	Holds a mesh for a mapblock.

	Besides the SMesh*, this contains information used for animating
	the vertex positions, colors and texture coordinates of the mesh.
	For example:
	- cracks [implemented]
	- day/night transitions [implemented]
	- animated flowing liquids [not implemented]
	- animating vertex positions for e.g. axles [not implemented]
*/
class MapBlockMesh
{
public:
	// Builds the mesh given
	MapBlockMesh(MeshMakeData *data, v3s16 camera_offset);
	~MapBlockMesh();

	// Main animation function, parameters:
	//   faraway: whether the block is far away from the camera (~50 nodes)
	//   time: the global animation time, 0 .. 60 (repeats every minute)
	//   daynight_ratio: 0 .. 1000
	//   crack: -1 .. CRACK_ANIMATION_LENGTH-1 (-1 for off)
	// Returns true if anything has been changed.
	bool animate(bool faraway, float time, int crack, u32 daynight_ratio);

	scene::SMesh* getMesh()
	{
		return m_mesh;
	}

	bool isAnimationForced() const
	{
		return m_animation_force_timer == 0;
	}

	void decreaseAnimationForceTimer()
	{
		if(m_animation_force_timer > 0)
			m_animation_force_timer--;
	}
	
	void updateCameraOffset(v3s16 camera_offset);

private:
	scene::SMesh *m_mesh;
	IGameDef *m_gamedef;

	bool m_enable_shaders;
	bool m_enable_highlighting;

	video::SColor m_highlight_mesh_color;
	
	// Must animate() be called before rendering?
	bool m_has_animation;
	int m_animation_force_timer;

	// Animation info: cracks
	// Last crack value passed to animate()
	int m_last_crack;
	// Maps mesh buffer (i.e. material) indices to base texture names
	std::map<u32, std::string> m_crack_materials;
	std::list<u32> m_highlighted_materials;

	// Animation info: texture animationi
	// Maps meshbuffers to TileSpecs
	std::map<u32, TileSpec> m_animation_tiles;
	std::map<u32, int> m_animation_frames; // last animation frame
	std::map<u32, int> m_animation_frame_offsets;
	
	// Animation info: day/night transitions
	// Last daynight_ratio value passed to animate()
	u32 m_last_daynight_ratio;
	// For each meshbuffer, maps vertex indices to (day,night) pairs
	std::map<u32, std::map<u32, std::pair<u8, u8> > > m_daynight_diffs;
	
	// Camera offset info -> do we have to translate the mesh?
	v3s16 m_camera_offset;
};



/*
	This is used because CMeshBuffer::append() is very slow
*/
struct PreMeshBuffer
{
	TileSpec tile;
	std::vector<u16> indices;
	std::vector<video::S3DVertex> vertices;
};

struct MeshCollector
{
	std::vector<PreMeshBuffer> prebuffers;

	void append(const TileSpec &material,
			const video::S3DVertex *vertices, u32 numVertices,
			const u16 *indices, u32 numIndices);
	void append(const TileSpec &material,
			const video::S3DVertex *vertices, u32 numVertices,
			const u16 *indices, u32 numIndices,
			v3f pos, video::SColor c);
};

// This encodes
//   alpha in the A channel of the returned SColor
//   day light (0-255) in the R channel of the returned SColor
//   night light (0-255) in the G channel of the returned SColor
//   light source (0-255) in the B channel of the returned SColor
inline video::SColor MapBlock_LightColor(u8 alpha, u16 light, u8 light_source=0)
{
	return video::SColor(alpha, (light & 0xff), (light >> 8), light_source);
}

// Compute light at node
u16 getInteriorLight(MapNode n, s32 increment, INodeDefManager *ndef);
u16 getFaceLight(MapNode n, MapNode n2, v3s16 face_dir, INodeDefManager *ndef);
u16 getSmoothLight(v3s16 p, v3s16 corner, MeshMakeData *data);

// Converts from day + night color values (0..255)
// and a given daynight_ratio to the final SColor shown on screen.
void finalColorBlend(video::SColor& result,
		u8 day, u8 night, u32 daynight_ratio);

// Retrieves the TileSpec of a face of a node
// Adds MATERIAL_FLAG_CRACK if the node is cracked
TileSpec getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data);
TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data);

#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-06 05:54:47 +0000
class="hl opt">= false; virtual ~LoadingBlockModifierDef() = default; virtual void trigger(ServerEnvironment *env, v3s16 p, MapNode n){}; }; struct LBMContentMapping { typedef std::unordered_map<content_t, std::vector<LoadingBlockModifierDef *>> lbm_map; lbm_map map; std::vector<LoadingBlockModifierDef *> lbm_list; // Needs to be separate method (not inside destructor), // because the LBMContentMapping may be copied and destructed // many times during operation in the lbm_lookup_map. void deleteContents(); void addLBM(LoadingBlockModifierDef *lbm_def, IGameDef *gamedef); const std::vector<LoadingBlockModifierDef *> *lookup(content_t c) const; }; class LBMManager { public: LBMManager() = default; ~LBMManager(); // Don't call this after loadIntroductionTimes() ran. void addLBMDef(LoadingBlockModifierDef *lbm_def); void loadIntroductionTimes(const std::string &times, IGameDef *gamedef, u32 now); // Don't call this before loadIntroductionTimes() ran. std::string createIntroductionTimesString(); // Don't call this before loadIntroductionTimes() ran. void applyLBMs(ServerEnvironment *env, MapBlock *block, u32 stamp); // Warning: do not make this std::unordered_map, order is relevant here typedef std::map<u32, LBMContentMapping> lbm_lookup_map; private: // Once we set this to true, we can only query, // not modify bool m_query_mode = false; // For m_query_mode == false: // The key of the map is the LBM def's name. // TODO make this std::unordered_map std::map<std::string, LoadingBlockModifierDef *> m_lbm_defs; // For m_query_mode == true: // The key of the map is the LBM def's first introduction time. lbm_lookup_map m_lbm_lookup; // Returns an iterator to the LBMs that were introduced // after the given time. This is guaranteed to return // valid values for everything lbm_lookup_map::const_iterator getLBMsIntroducedAfter(u32 time) { return m_lbm_lookup.lower_bound(time); } }; /* List of active blocks, used by ServerEnvironment */ class ActiveBlockList { public: void update(std::vector<PlayerSAO*> &active_players, s16 active_block_range, s16 active_object_range, std::set<v3s16> &blocks_removed, std::set<v3s16> &blocks_added); bool contains(v3s16 p){ return (m_list.find(p) != m_list.end()); } void clear(){ m_list.clear(); } std::set<v3s16> m_list; std::set<v3s16> m_abm_list; std::set<v3s16> m_forceloaded_list; private: }; /* Operation mode for ServerEnvironment::clearObjects() */ enum ClearObjectsMode { // Load and go through every mapblock, clearing objects CLEAR_OBJECTS_MODE_FULL, // Clear objects immediately in loaded mapblocks; // clear objects in unloaded mapblocks only when the mapblocks are next activated. CLEAR_OBJECTS_MODE_QUICK, }; /* The server-side environment. This is not thread-safe. Server uses an environment mutex. */ typedef std::unordered_map<u16, ServerActiveObject *> ServerActiveObjectMap; class ServerEnvironment : public Environment { public: ServerEnvironment(ServerMap *map, ServerScripting *scriptIface, Server *server, const std::string &path_world); ~ServerEnvironment(); Map & getMap(); ServerMap & getServerMap(); //TODO find way to remove this fct! ServerScripting* getScriptIface() { return m_script; } Server *getGameDef() { return m_server; } float getSendRecommendedInterval() { return m_recommended_send_interval; } void kickAllPlayers(AccessDeniedCode reason, const std::string &str_reason, bool reconnect); // Save players void saveLoadedPlayers(bool force = false); void savePlayer(RemotePlayer *player); PlayerSAO *loadPlayer(RemotePlayer *player, bool *new_player, session_t peer_id, bool is_singleplayer); void addPlayer(RemotePlayer *player); void removePlayer(RemotePlayer *player); bool removePlayerFromDatabase(const std::string &name); /* Save and load time of day and game timer */ void saveMeta(); void loadMeta(); u32 addParticleSpawner(float exptime); u32 addParticleSpawner(float exptime, u16 attached_id); void deleteParticleSpawner(u32 id, bool remove_from_object = true); /* External ActiveObject interface ------------------------------------------- */ ServerActiveObject* getActiveObject(u16 id) { return m_ao_manager.getActiveObject(id); } /* Add an active object to the environment. Environment handles deletion of object. Object may be deleted by environment immediately. If id of object is 0, assigns a free id to it. Returns the id of the object. Returns 0 if not added and thus deleted. */ u16 addActiveObject(ServerActiveObject *object); /* Add an active object as a static object to the corresponding MapBlock. Caller allocates memory, ServerEnvironment frees memory. Return value: true if succeeded, false if failed. (note: not used, pending removal from engine) */ //bool addActiveObjectAsStatic(ServerActiveObject *object); /* Find out what new objects have been added to inside a radius around a position */ void getAddedActiveObjects(PlayerSAO *playersao, s16 radius, s16 player_radius, std::set<u16> &current_objects, std::queue<u16> &added_objects); /* Find out what new objects have been removed from inside a radius around a position */ void getRemovedActiveObjects(PlayerSAO *playersao, s16 radius, s16 player_radius, std::set<u16> &current_objects, std::queue<u16> &removed_objects); /* Get the next message emitted by some active object. Returns a message with id=0 if no messages are available. */ ActiveObjectMessage getActiveObjectMessage(); virtual void getSelectedActiveObjects( const core::line3d<f32> &shootline_on_map, std::vector<PointedThing> &objects ); /* Activate objects and dynamically modify for the dtime determined from timestamp and additional_dtime */ void activateBlock(MapBlock *block, u32 additional_dtime=0); /* {Active,Loading}BlockModifiers ------------------------------------------- */ void addActiveBlockModifier(ActiveBlockModifier *abm); void addLoadingBlockModifierDef(LoadingBlockModifierDef *lbm); /* Other stuff ------------------------------------------- */ // Script-aware node setters bool setNode(v3s16 p, const MapNode &n); bool removeNode(v3s16 p); bool swapNode(v3s16 p, const MapNode &n); // Find all active objects inside a radius around a point void getObjectsInsideRadius(std::vector<u16> &objects, const v3f &pos, float radius) { return m_ao_manager.getObjectsInsideRadius(pos, radius, objects); } // Clear objects, loading and going through every MapBlock void clearObjects(ClearObjectsMode mode); // This makes stuff happen void step(f32 dtime); /*! * Returns false if the given line intersects with a * non-air node, true otherwise. * \param pos1 start of the line * \param pos2 end of the line * \param p output, position of the first non-air node * the line intersects */ bool line_of_sight(v3f pos1, v3f pos2, v3s16 *p = NULL); u32 getGameTime() const { return m_game_time; } void reportMaxLagEstimate(float f) { m_max_lag_estimate = f; } float getMaxLagEstimate() { return m_max_lag_estimate; } std::set<v3s16>* getForceloadedBlocks() { return &m_active_blocks.m_forceloaded_list; }; // Sets the static object status all the active objects in the specified block // This is only really needed for deleting blocks from the map void setStaticForActiveObjectsInBlock(v3s16 blockpos, bool static_exists, v3s16 static_block=v3s16(0,0,0)); RemotePlayer *getPlayer(const session_t peer_id); RemotePlayer *getPlayer(const char* name); u32 getPlayerCount() const { return m_players.size(); } static bool migratePlayersDatabase(const GameParams &game_params, const Settings &cmd_args); AuthDatabase *getAuthDatabase() { return m_auth_database; } static bool migrateAuthDatabase(const GameParams &game_params, const Settings &cmd_args); private: /** * called if env_meta.txt doesn't exist (e.g. new world) */ void loadDefaultMeta(); static PlayerDatabase *openPlayerDatabase(const std::string &name, const std::string &savedir, const Settings &conf); static AuthDatabase *openAuthDatabase(const std::string &name, const std::string &savedir, const Settings &conf); /* Internal ActiveObject interface ------------------------------------------- */ /* Add an active object to the environment. Called by addActiveObject. Object may be deleted by environment immediately. If id of object is 0, assigns a free id to it. Returns the id of the object. Returns 0 if not added and thus deleted. */ u16 addActiveObjectRaw(ServerActiveObject *object, bool set_changed, u32 dtime_s); /* Remove all objects that satisfy (isGone() && m_known_by_count==0) */ void removeRemovedObjects(); /* Convert stored objects from block to active */ void activateObjects(MapBlock *block, u32 dtime_s); /* Convert objects that are not in active blocks to static. If m_known_by_count != 0, active object is not deleted, but static data is still updated. If force_delete is set, active object is deleted nevertheless. It shall only be set so in the destructor of the environment. */ void deactivateFarObjects(bool force_delete); /* A few helpers used by the three above methods */ void deleteStaticFromBlock( ServerActiveObject *obj, u16 id, u32 mod_reason, bool no_emerge); bool saveStaticToBlock(v3s16 blockpos, u16 store_id, ServerActiveObject *obj, const StaticObject &s_obj, u32 mod_reason); /* Member variables */ // The map ServerMap *m_map; // Lua state ServerScripting* m_script; // Server definition Server *m_server; // Active Object Manager server::ActiveObjectMgr m_ao_manager; // World path const std::string m_path_world; // Outgoing network message buffer for active objects std::queue<ActiveObjectMessage> m_active_object_messages; // Some timers float m_send_recommended_timer = 0.0f; IntervalLimiter m_object_management_interval; // List of active blocks ActiveBlockList m_active_blocks; IntervalLimiter m_active_blocks_management_interval; IntervalLimiter m_active_block_modifier_interval; IntervalLimiter m_active_blocks_nodemetadata_interval; // Time from the beginning of the game in seconds. // Incremented in step(). u32 m_game_time = 0; // A helper variable for incrementing the latter float m_game_time_fraction_counter = 0.0f; // Time of last clearObjects call (game time). // When a mapblock older than this is loaded, its objects are cleared. u32 m_last_clear_objects_time = 0; // Active block modifiers std::vector<ABMWithState> m_abms; LBMManager m_lbm_mgr; // An interval for generally sending object positions and stuff float m_recommended_send_interval = 0.1f; // Estimate for general maximum lag as determined by server. // Can raise to high values like 15s with eg. map generation mods. float m_max_lag_estimate = 0.1f; // peer_ids in here should be unique, except that there may be many 0s std::vector<RemotePlayer*> m_players; PlayerDatabase *m_player_database = nullptr; AuthDatabase *m_auth_database = nullptr; // Pseudo random generator for shuffling, etc. std::mt19937 m_rgen; // Particles IntervalLimiter m_particle_management_interval; std::unordered_map<u32, float> m_particle_spawners; std::unordered_map<u32, u16> m_particle_spawner_attachments; };
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-06 05:54:47 +0000