Luanti 5.19.0-dev
Loading...
Searching...
No Matches
mapblock_mesh.h
Go to the documentation of this file.
1// Luanti
2// SPDX-License-Identifier: LGPL-2.1-or-later
3// Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
4
5#pragma once
6
7#include "irrlichttypes.h"
8#include "irr_ptr.h"
9#include "IMesh.h"
10#include "CMeshBuffer.h"
11
12#include "util/numeric.h"
13#include "client/tile.h"
14#include "voxel.h"
15#include <map>
16
17namespace video {
18 class IVideoDriver;
19}
20
21class Client;
22class NodeDefManager;
23class IShaderSource;
24class ITextureSource;
25struct LightPair;
26
27/*
28 Mesh making stuff
29*/
30
31
32struct MinimapMapblock;
33
35{
37
38 // base pos of meshgen area, in blocks
39 v3s16 m_blockpos = v3s16(-1337,-1337,-1337);
40 // size of meshgen area, in nodes.
41 // vmanip will have at least an extra 1 node onion layer.
42 // area is expected to fit into mesh grid cell.
44 // vertex positions will be relative to this grid
46
47 // relative to blockpos
48 v3s16 m_crack_pos_relative = v3s16(-1337,-1337,-1337);
49 float m_ao_gamma_inv = 0.0f;
50 bool m_generate_minimap = false;
51 bool m_smooth_lighting = false;
54
56
57 MeshMakeData(const NodeDefManager *ndef, u16 side_lingth, MeshGrid mesh_grid);
58
59 /*
60 Copy block data manually (to allow optimizations by the caller)
61 */
62 void fillBlockDataBegin(const v3s16 &blockpos);
63
64 /*
65 Prepare block data for rendering a single node located at (0,0,0).
66 */
67 void fillSingleNode(MapNode data, MapNode padding = MapNode(CONTENT_AIR));
68
69 /*
70 Set the (node) position of a crack
71 */
72 void setCrack(int crack_level, v3s16 crack_pos);
73};
74
75// represents a triangle as indexes into the vertex buffer in SMeshBuffer
77{
78public:
79 scene::SMeshBuffer *buffer;
80 u16 p1, p2, p3;
82 float areaSQ;
83
85 {
86 v3f v1 = buffer->getPosition(p1);
87 v3f v2 = buffer->getPosition(p2);
88 v3f v3 = buffer->getPosition(p3);
89
90 centroid = (v1 + v2 + v3) / 3;
91 areaSQ = (v2-v1).crossProduct(v3-v1).getLengthSQ() / 4;
92 }
93
94 v3f getNormal() const {
95 v3f v1 = buffer->getPosition(p1);
96 v3f v2 = buffer->getPosition(p2);
97 v3f v3 = buffer->getPosition(p3);
98
99 return (v2-v1).crossProduct(v3-v1);
100 }
101};
102
108{
109public:
111
112 void buildTree(const std::vector<MeshTriangle> *triangles, u16 side_lingth);
113
114 void traverse(v3f viewpoint, std::vector<s32> &output) const
115 {
116 traverse(root, viewpoint, output);
117 }
118
119private:
120 // Tree node definition;
134
135
136 s32 buildTree(v3f normal, v3f origin, float delta, const std::vector<s32> &list, u32 depth);
137 void traverse(s32 node, v3f viewpoint, std::vector<s32> &output) const;
138
139 const std::vector<MeshTriangle> *triangles = nullptr; // this reference is managed externally
140 std::vector<TreeNode> nodes; // list of nodes
141 s32 root = -1; // index of the root node
142};
143
144/*
145 * PartialMeshBuffer
146 *
147 * Attach alternate `Indices` to an existing mesh buffer, to make it possible to use different
148 * indices with the same vertex buffer.
149 */
151{
152public:
153 PartialMeshBuffer(scene::SMeshBuffer *buffer, std::vector<u16> &&vertex_indices) :
154 m_buffer(buffer), m_indices(make_irr<scene::SIndexBuffer>())
155 {
156 m_indices->Data = std::move(vertex_indices);
157 m_indices->MappingHint = scene::EHM_STATIC;
158 }
159
160 auto *getBuffer() const { return m_buffer; }
161
162 void draw(video::IVideoDriver *driver) const;
163
164private:
165 scene::SMeshBuffer *m_buffer;
166 irr_ptr<scene::SIndexBuffer> m_indices;
167};
168
169/*
170 Holds a mesh for a mapblock.
171
172 Besides the SMesh*, this contains information used fortransparency sorting
173 and texture animation.
174 For example:
175 - cracks
176 - day/night transitions
177*/
179{
180public:
181 // Builds the mesh given
184
185 // Main animation function, parameters:
186 // faraway: whether the block is far away from the camera (~50 nodes)
187 // time: the global animation time, 0 .. 60 (repeats every minute)
188 // daynight_ratio: 0 .. 1000
189 // crack: -1 .. CRACK_ANIMATION_LENGTH (-1 for off)
190 // Returns true if anything has been changed.
191 bool animate(bool faraway, float time, int crack, u32 daynight_ratio);
192
194 scene::IMesh *getMesh()
195 {
196 return m_mesh[0].get();
197 }
198
201 scene::IMesh *getMesh(u8 layer)
202 {
203 assert(layer < MAX_TILE_LAYERS);
204 return m_mesh[layer].get();
205 }
206
207 std::vector<MinimapMapblock*> moveMinimapMapblocks()
208 {
209 std::vector<MinimapMapblock*> minimap_mapblocks;
210 minimap_mapblocks.swap(m_minimap_mapblocks);
211 return minimap_mapblocks;
212 }
213
215 bool isEmpty() const
216 {
217 if (!m_transparent_triangles.empty())
218 return false;
219 for (auto &mesh : m_mesh) {
220 for (u32 i = 0; i < mesh->getMeshBufferCount(); i++) {
221 if (mesh->getMeshBuffer(i)->getIndexCount() != 0)
222 return false;
223 }
224 }
225 return true;
226 }
227
228 bool isAnimationForced() const
229 {
230 return m_animation_force_timer == 0;
231 }
232
238
240 f32 getBoundingRadius() const { return m_bounding_radius; }
241
244
252 void updateTransparentBuffers(v3f camera_pos, v3s16 block_pos, bool group_by_buffers);
254
256 const std::vector<PartialMeshBuffer> &getTransparentBuffers() const
257 {
259 }
260
264 static const int TEXTURE_LAYER_CRACK = 1;
265
266 static float packCrackMaterialParam(int crack, u8 layer_scale)
267 {
268 // +1 so that the default MaterialTypeParam = 0 is a no-op,
269 // since the shader needs to know when to actually apply the crack.
270 u32 n = (layer_scale << 16) | (u16) (crack + 1);
271 return n;
272 }
273 static std::pair<int, u8> unpackCrackMaterialParam(float param)
274 {
275 u32 n = param;
276 return std::make_pair<int, u8>((n & 0xffff) - 1, (n >> 16) & 0xff);
277 }
278
279private:
280
281 typedef std::pair<u8 /* layer index */, u32 /* buffer index */> MeshIndex;
282
283 irr_ptr<scene::IMesh> m_mesh[MAX_TILE_LAYERS];
284 std::vector<MinimapMapblock*> m_minimap_mapblocks;
287
290
291 // Must animate() be called before rendering?
294
295 // Animation info: cracks
296 // Last crack value passed to animate()
298 // Indicates which materials to apply the crack to
299 std::vector<MeshIndex> m_crack_materials;
300
301 // Animation info: texture animation
302 // Maps mesh and mesh buffer indices to TileSpecs
303 std::map<MeshIndex, AnimationInfo> m_animation_info;
304
305 // list of all semitransparent triangles in the mapblock
306 std::vector<MeshTriangle> m_transparent_triangles;
307 // Binary Space Partitioning tree for the block
309 // Ordered list of references to parts of transparent buffers to draw
310 std::vector<PartialMeshBuffer> m_transparent_buffers;
311 // Is m_transparent_buffers currently in consolidated form?
313};
314
327video::SColor encode_light(u16 light, u8 emissive_light);
328video::SColor encode_light(LightPair light, u8 emissive_light);
329
330// Compute light at node
331u16 getInteriorLight(MapNode n, s32 increment, const NodeDefManager *ndef);
332
337void get_sunlight_color(video::SColorf *sunlight, u32 daynight_ratio);
338
346void final_color_blend(video::SColor *result,
347 u16 light, u32 daynight_ratio);
348
356void final_color_blend(video::SColor *result,
357 const video::SColor &data, const video::SColorf &dayLight);
358
359// Retrieves the TileSpec of a face of a node
360// Adds MATERIAL_FLAG_CRACK if the node is cracked
361// TileSpec should be passed as reference due to the underlying TileFrame and its vector
362// TileFrame vector copy cost very much to client
363void getNodeTileN(MapNode mn, const v3s16 &p, u8 tileindex, MeshMakeData *data, TileSpec &tile);
364void getNodeTile(MapNode mn, const v3s16 &p, const v3s16 &dir, MeshMakeData *data, TileSpec &tile);
365
Definition client.h:108
Definition shader.h:254
Definition texturesource.h:45
Implements a binary space partitioning tree See also: https://en.wikipedia.org/wiki/Binary_space_part...
Definition mapblock_mesh.h:108
std::vector< TreeNode > nodes
Definition mapblock_mesh.h:140
void buildTree(const std::vector< MeshTriangle > *triangles, u16 side_lingth)
Definition mapblock_mesh.cpp:246
const std::vector< MeshTriangle > * triangles
Definition mapblock_mesh.h:139
s32 root
Definition mapblock_mesh.h:141
void traverse(v3f viewpoint, std::vector< s32 > &output) const
Definition mapblock_mesh.h:114
MapBlockBspTree()
Definition mapblock_mesh.h:110
std::vector< MinimapMapblock * > m_minimap_mapblocks
Definition mapblock_mesh.h:284
static const int TEXTURE_LAYER_CRACK
Texture layer in SMaterial where the crack texture is put.
Definition mapblock_mesh.h:264
std::map< MeshIndex, AnimationInfo > m_animation_info
Definition mapblock_mesh.h:303
f32 getBoundingRadius() const
Radius of the bounding-sphere, in BS-space.
Definition mapblock_mesh.h:240
bool isAnimationForced() const
Definition mapblock_mesh.h:228
MapBlockMesh(Client *client, MeshMakeData *data)
Definition mapblock_mesh.cpp:454
const std::vector< PartialMeshBuffer > & getTransparentBuffers() const
get the list of transparent buffers
Definition mapblock_mesh.h:256
v3f getBoundingSphereCenter() const
Center of the bounding-sphere, in BS-space, relative to block pos.
Definition mapblock_mesh.h:243
int m_animation_force_timer
Definition mapblock_mesh.h:293
MapBlockBspTree m_bsp_tree
Definition mapblock_mesh.h:308
std::vector< MinimapMapblock * > moveMinimapMapblocks()
Definition mapblock_mesh.h:207
bool isEmpty() const
Definition mapblock_mesh.h:215
void consolidateTransparentBuffers()
Definition mapblock_mesh.cpp:701
f32 m_bounding_radius
Definition mapblock_mesh.h:288
scene::IMesh * getMesh()
Definition mapblock_mesh.h:194
bool animate(bool faraway, float time, int crack, u32 daynight_ratio)
Definition mapblock_mesh.cpp:596
void decreaseAnimationForceTimer()
Definition mapblock_mesh.h:233
std::pair< u8, u32 > MeshIndex
Definition mapblock_mesh.h:281
void updateTransparentBuffers(v3f camera_pos, v3s16 block_pos, bool group_by_buffers)
Update transparent buffers to render towards the camera.
Definition mapblock_mesh.cpp:632
std::vector< MeshIndex > m_crack_materials
Definition mapblock_mesh.h:299
std::vector< MeshTriangle > m_transparent_triangles
Definition mapblock_mesh.h:306
irr_ptr< scene::IMesh > m_mesh[MAX_TILE_LAYERS]
Definition mapblock_mesh.h:283
static std::pair< int, u8 > unpackCrackMaterialParam(float param)
Definition mapblock_mesh.h:273
bool m_transparent_buffers_consolidated
Definition mapblock_mesh.h:312
static float packCrackMaterialParam(int crack, u8 layer_scale)
Definition mapblock_mesh.h:266
IShaderSource * m_shdrsrc
Definition mapblock_mesh.h:286
ITextureSource * m_tsrc
Definition mapblock_mesh.h:285
int m_last_crack
Definition mapblock_mesh.h:297
bool m_has_animation
Definition mapblock_mesh.h:292
scene::IMesh * getMesh(u8 layer)
Definition mapblock_mesh.h:201
v3f m_bounding_sphere_center
Definition mapblock_mesh.h:289
std::vector< PartialMeshBuffer > m_transparent_buffers
Definition mapblock_mesh.h:310
Definition mapblock_mesh.h:77
scene::SMeshBuffer * buffer
Definition mapblock_mesh.h:79
u16 p3
Definition mapblock_mesh.h:80
float areaSQ
Definition mapblock_mesh.h:82
v3f getNormal() const
Definition mapblock_mesh.h:94
u16 p2
Definition mapblock_mesh.h:80
v3f centroid
Definition mapblock_mesh.h:81
void updateAttributes()
Definition mapblock_mesh.h:84
u16 p1
Definition mapblock_mesh.h:80
This class is for getting the actual properties of nodes from their content ID.
Definition nodedef.h:514
void draw(video::IVideoDriver *driver) const
Definition mapblock_mesh.cpp:402
irr_ptr< scene::SIndexBuffer > m_indices
Definition mapblock_mesh.h:166
scene::SMeshBuffer * m_buffer
Definition mapblock_mesh.h:165
PartialMeshBuffer(scene::SMeshBuffer *buffer, std::vector< u16 > &&vertex_indices)
Definition mapblock_mesh.h:153
auto * getBuffer() const
Definition mapblock_mesh.h:160
Definition voxel.h:365
core::vector3d< s16 > v3s16
Definition irr_v3d.h:13
core::vector3df v3f
Definition irr_v3d.h:11
void getNodeTileN(MapNode mn, const v3s16 &p, u8 tileindex, MeshMakeData *data, TileSpec &tile)
Definition mapblock_mesh.cpp:156
u8 get_solid_sides(MeshMakeData *data)
Return bitset of the sides of the mesh that consist of solid nodes only Bits: 0 0 -Z +Z -X +X -Y +Y.
Definition mapblock_mesh.cpp:763
void final_color_blend(video::SColor *result, u16 light, u32 daynight_ratio)
Definition mapblock_mesh.cpp:113
video::SColor encode_light(LightPair light, u8 emissive_light)
Definition mapblock_mesh.cpp:731
void getNodeTile(MapNode mn, const v3s16 &p, const v3s16 &dir, MeshMakeData *data, TileSpec &tile)
Definition mapblock_mesh.cpp:176
void get_sunlight_color(video::SColorf *sunlight, u32 daynight_ratio)
Definition mapblock_mesh.cpp:104
static u8 getInteriorLight(enum LightBank bank, MapNode n, s32 increment, const NodeDefManager *ndef)
Definition mapblock_mesh.cpp:85
#define CONTENT_AIR
Definition mapnode.h:40
Definition activeobjectmgr.cpp:11
Definition camera.h:24
Definition clientmap.h:36
Definition content_mapblock.h:13
v3f normal
Definition mapblock_mesh.h:123
std::vector< s32 > triangle_refs
Definition mapblock_mesh.h:125
v3f origin
Definition mapblock_mesh.h:124
s32 front_ref
Definition mapblock_mesh.h:126
s32 back_ref
Definition mapblock_mesh.h:127
TreeNode(v3f normal, v3f origin, const std::vector< s32 > &triangle_refs, s32 front_ref, s32 back_ref)
Definition mapblock_mesh.h:130
Definition mapnode.h:115
MapNode()=default
Describes a grid with given step, originating at (0,0,0).
Definition numeric.h:157
Definition mapblock_mesh.h:35
void fillBlockDataBegin(const v3s16 &blockpos)
Definition mapblock_mesh.cpp:40
v3s16 m_crack_pos_relative
Definition mapblock_mesh.h:48
bool m_enable_waving_water
Definition mapblock_mesh.h:53
bool m_smooth_lighting
Definition mapblock_mesh.h:51
void fillSingleNode(MapNode data, MapNode padding=MapNode(CONTENT_AIR))
Definition mapblock_mesh.cpp:53
const NodeDefManager * m_nodedef
Definition mapblock_mesh.h:55
float m_ao_gamma_inv
Definition mapblock_mesh.h:49
VoxelManipulator m_vmanip
Definition mapblock_mesh.h:36
MeshGrid m_mesh_grid
Definition mapblock_mesh.h:45
u16 m_side_length
Definition mapblock_mesh.h:43
bool m_enable_water_reflections
Definition mapblock_mesh.h:52
void setCrack(int crack_level, v3s16 crack_pos)
Definition mapblock_mesh.cpp:71
MeshMakeData(const NodeDefManager *ndef, u16 side_lingth, MeshGrid mesh_grid)
Definition mapblock_mesh.cpp:31
bool m_generate_minimap
Definition mapblock_mesh.h:50
v3s16 m_blockpos
Definition mapblock_mesh.h:39
Definition minimap.h:68
Definition tile.h:233
#define MAX_TILE_LAYERS
We have two tile layers: layer 0 = base layer 1 = overlay.
Definition tile.h:71