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
|
/*
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.
*/
#pragma once
#include "nodedef.h"
#include <IMeshManipulator.h>
struct MeshMakeData;
struct MeshCollector;
struct LightPair {
u8 lightA;
u8 lightB;
LightPair() = default;
explicit LightPair(u16 value) : lightA(value & 0xff), lightB(value >> 8) {}
LightPair(u8 valueA, u8 valueB) : lightA(valueA), lightB(valueB) {}
LightPair(float valueA, float valueB) :
lightA(core::clamp(core::round32(valueA), 0, 255)),
lightB(core::clamp(core::round32(valueB), 0, 255)) {}
operator u16() const { return lightA | lightB << 8; }
};
struct LightFrame {
f32 lightsA[8];
f32 lightsB[8];
};
class MapblockMeshGenerator
{
public:
MeshMakeData *data;
MeshCollector *collector;
INodeDefManager *nodedef;
scene::IMeshManipulator *meshmanip;
// options
bool enable_mesh_cache;
// current node
v3s16 blockpos_nodes;
v3s16 p;
v3f origin;
MapNode n;
const ContentFeatures *f;
LightPair light;
LightFrame frame;
video::SColor color;
TileSpec tile;
float scale;
// lighting
void getSmoothLightFrame();
LightPair blendLight(const v3f &vertex_pos);
video::SColor blendLightColor(const v3f &vertex_pos);
video::SColor blendLightColor(const v3f &vertex_pos, const v3f &vertex_normal);
void useTile(int index = 0, u8 set_flags = MATERIAL_FLAG_CRACK_OVERLAY,
u8 reset_flags = 0, bool special = false);
void getTile(int index, TileSpec *tile);
void getTile(v3s16 direction, TileSpec *tile);
void getSpecialTile(int index, TileSpec *tile, bool apply_crack = false);
// face drawing
void drawQuad(v3f *vertices, const v3s16 &normal = v3s16(0, 0, 0),
float vertical_tiling = 1.0);
// cuboid drawing!
void drawCuboid(const aabb3f &box, TileSpec *tiles, int tilecount,
const LightPair *lights , const f32 *txc);
void generateCuboidTextureCoords(aabb3f const &box, f32 *coords);
void drawAutoLightedCuboid(aabb3f box, const f32 *txc = NULL,
TileSpec *tiles = NULL, int tile_count = 0);
// liquid-specific
bool top_is_same_liquid;
bool draw_liquid_bottom;
TileSpec tile_liquid;
TileSpec tile_liquid_top;
content_t c_flowing;
content_t c_source;
video::SColor color_liquid_top;
struct NeighborData {
f32 level;
content_t content;
bool is_same_liquid;
bool top_is_same_liquid;
};
NeighborData liquid_neighbors[3][3];
f32 corner_levels[2][2];
void prepareLiquidNodeDrawing();
void getLiquidNeighborhood();
void calculateCornerLevels();
f32 getCornerLevel(int i, int k);
void drawLiquidSides();
void drawLiquidTop();
void drawLiquidBottom();
// raillike-specific
// name of the group that enables connecting to raillike nodes of different kind
static const std::string raillike_groupname;
int raillike_group;
bool isSameRail(v3s16 dir);
// plantlike-specific
PlantlikeStyle draw_style;
v3f offset;
int rotate_degree;
bool random_offset_Y;
int face_num;
float plant_height;
void drawPlantlikeQuad(float rotation, float quad_offset = 0,
bool offset_top_only = false);
void drawPlantlike();
// firelike-specific
void drawFirelikeQuad(float rotation, float opening_angle,
float offset_h, float offset_v = 0.0);
// drawtypes
void drawLiquidNode();
void drawGlasslikeNode();
void drawGlasslikeFramedNode();
void drawAllfacesNode();
void drawTorchlikeNode();
void drawSignlikeNode();
void drawPlantlikeNode();
void drawPlantlikeRootedNode();
void drawFirelikeNode();
void drawFencelikeNode();
void drawRaillikeNode();
void drawNodeboxNode();
void drawMeshNode();
// common
void errorUnknownDrawtype();
void drawNode();
public:
MapblockMeshGenerator(MeshMakeData *input, MeshCollector *output);
void generate();
void renderSingle(content_t node);
};
|
