BRNSystems/minetest
1
0
Fork 0
forked from Mirrorlandia_minetest/minetest
Code Pull Requests 1 Activity

Soft node overlay (#5186)

Browse Source 
This commit adds node overlays, which are tiles that are drawn on top of
other tiles.
This commit is contained in:
Dániel Juhász 2017-04-21 15:34:59 +02:00 committed by Zeno-
parent 2ad74a9e8b
commit 1ffb180868
18 changed files with 763 additions and 467 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
doc/lua_api.txt
View File

@ -3908,6 +3908,12 @@ Definition tables
tiles = {tile definition 1, def2, def3, def4, def5, def6}, --[[
^ Textures of node; +Y, -Y, +X, -X, +Z, -Z (old field name: tile_images)
^ List can be shortened to needed length ]]
overlay_tiles = {tile definition 1, def2, def3, def4, def5, def6}, --[[
^ Same as `tiles`, but these textures are drawn on top of the
^ base tiles. You can use this to colorize only specific parts of
^ your texture. If the texture name is an empty string, that
^ overlay is not drawn. Since such tiles are drawn twice, it
^ is not recommended to use overlays on very common nodes.
special_tiles = {tile definition 1, Tile definition 2}, --[[
^ Special textures of node; used rarely (old field name: special_materials)
^ List can be shortened to needed length ]]

16
src/client.cpp
View File

@ -487,13 +487,17 @@ void Client::step(float dtime)
minimap_mapblock = r.mesh->moveMinimapMapblock();
if (minimap_mapblock == NULL)
do_mapper_update = false;
}
if (r.mesh && r.mesh->getMesh()->getMeshBufferCount() == 0) {
delete r.mesh;
} else {
// Replace with the new mesh
block->mesh = r.mesh;
bool is_empty = true;
for (int l = 0; l < MAX_TILE_LAYERS; l++)
if (r.mesh->getMesh(l)->getMeshBufferCount() != 0)
is_empty = false;
if (is_empty)
delete r.mesh;
else
// Replace with the new mesh
block->mesh = r.mesh;
}
} else {
delete r.mesh;

96
src/client/tile.h
View File

@ -194,19 +194,22 @@ struct FrameSpec
video::ITexture *flags_texture;
};
struct TileSpec
#define MAX_TILE_LAYERS 2
//! Defines a layer of a tile.
struct TileLayer
{
TileSpec():
TileLayer():
texture(NULL),
texture_id(0),
color(),
material_type(TILE_MATERIAL_BASIC),
material_flags(
//0 // <- DEBUG, Use the one below
MATERIAL_FLAG_BACKFACE_CULLING
MATERIAL_FLAG_BACKFACE_CULLING |
MATERIAL_FLAG_TILEABLE_HORIZONTAL|
MATERIAL_FLAG_TILEABLE_VERTICAL
),
rotation(0),
emissive_light(0),
shader_id(0),
normal_texture(NULL),
flags_texture(NULL),
@ -217,49 +220,41 @@ struct TileSpec
}
/*!
* Two tiles are equal if they can be appended to
* the same mesh buffer.
* Two layers are equal if they can be merged.
*/
bool operator==(const TileSpec &other) const
bool operator==(const TileLayer &other) const
{
return (
return
texture_id == other.texture_id &&
material_type == other.material_type &&
material_flags == other.material_flags &&
rotation == other.rotation
);
color == other.color;
}
/*!
* Two tiles are not equal if they must be in different mesh buffers.
* Two tiles are not equal if they must have different vertices.
*/
bool operator!=(const TileSpec &other) const
bool operator!=(const TileLayer &other) const
{
return !(*this == other);
}
// Sets everything else except the texture in the material
void applyMaterialOptions(video::SMaterial &material) const
{
switch (material_type) {
case TILE_MATERIAL_BASIC:
case TILE_MATERIAL_WAVING_LEAVES:
case TILE_MATERIAL_WAVING_PLANTS:
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
break;
case TILE_MATERIAL_ALPHA:
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
break;
case TILE_MATERIAL_LIQUID_TRANSPARENT:
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
break;
case TILE_MATERIAL_LIQUID_OPAQUE:
material.MaterialType = video::EMT_SOLID;
break;
case TILE_MATERIAL_WAVING_LEAVES:
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
break;
case TILE_MATERIAL_WAVING_PLANTS:
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
break;
}
material.BackfaceCulling = (material_flags & MATERIAL_FLAG_BACKFACE_CULLING)
? true : false;
@ -285,26 +280,26 @@ struct TileSpec
}
}
// ordered for performance! please do not reorder unless you pahole it first.
bool isTileable() const
{
return (material_flags & MATERIAL_FLAG_TILEABLE_HORIZONTAL)
&& (material_flags & MATERIAL_FLAG_TILEABLE_VERTICAL);
}
video::ITexture *texture;
u32 texture_id;
// The color of the tile, or if the tile does not own
// a color then the color of the node owning this tile.
/*!
* The color of the tile, or if the tile does not own
* a color then the color of the node owning this tile.
*/
video::SColor color;
// Material parameters
u8 material_type;
u8 material_flags;
u8 rotation;
//! This much light does the tile emit.
u8 emissive_light;
u32 shader_id;
video::ITexture *normal_texture;
// cacheline (64)
video::ITexture *flags_texture;
// Animation parameters
u16 animation_frame_length_ms;
u8 animation_frame_count;
@ -313,4 +308,39 @@ struct TileSpec
std::vector<FrameSpec> frames;
};
/*!
* Defines a face of a node. May have up to two layers.
*/
struct TileSpec
{
TileSpec():
rotation(0),
emissive_light(0)
{
for (int layer = 0; layer < MAX_TILE_LAYERS; layer++)
layers[layer] = TileLayer();
}
/*!
* Returns true if this tile can be merged with the other tile.
*/
bool isTileable(const TileSpec &other) const {
for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
if (layers[layer] != other.layers[layer])
return false;
if (!layers[layer].isTileable())
return false;
}
return rotation == 0
&& rotation == other.rotation
&& emissive_light == other.emissive_light;
}
u8 rotation;
//! This much light does the tile emit.
u8 emissive_light;
//! The first is base texture, the second is overlay.
TileLayer layers[MAX_TILE_LAYERS];
};
#endif

52
src/clientmap.cpp
View File

@ -290,6 +290,11 @@ void ClientMap::updateDrawList(video::IVideoDriver* driver)
struct MeshBufList
{
/*!
* Specifies in which layer the list is.
* All lists which are in a lower layer are rendered before this list.
*/
u8 layer;
video::SMaterial m;
std::vector<scene::IMeshBuffer*> bufs;
};
@ -303,7 +308,7 @@ struct MeshBufListList
lists.clear();
}
void add(scene::IMeshBuffer *buf)
void add(scene::IMeshBuffer *buf, u8 layer)
{
const video::SMaterial &m = buf->getMaterial();
for(std::vector<MeshBufList>::iterator i = lists.begin();
@ -315,12 +320,16 @@ struct MeshBufListList
if (l.m.TextureLayer[0].Texture != m.TextureLayer[0].Texture)
continue;
if(l.layer != layer)
continue;
if (l.m == m) {
l.bufs.push_back(buf);
return;
}
}
MeshBufList l;
l.layer = layer;
l.m = m;
l.bufs.push_back(buf);
lists.push_back(l);
@ -434,29 +443,34 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
MapBlockMesh *mapBlockMesh = block->mesh;
assert(mapBlockMesh);
scene::IMesh *mesh = mapBlockMesh->getMesh();
assert(mesh);
for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
scene::IMesh *mesh = mapBlockMesh->getMesh(layer);
assert(mesh);
u32 c = mesh->getMeshBufferCount();
for (u32 i = 0; i < c; i++)
{
scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
u32 c = mesh->getMeshBufferCount();
for (u32 i = 0; i < c; i++) {
scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
video::SMaterial& material = buf->getMaterial();
video::IMaterialRenderer* rnd =
video::SMaterial& material = buf->getMaterial();
video::IMaterialRenderer* rnd =
driver->getMaterialRenderer(material.MaterialType);
bool transparent = (rnd && rnd->isTransparent());
if (transparent == is_transparent_pass) {
if (buf->getVertexCount() == 0)
errorstream << "Block [" << analyze_block(block)
<< "] contains an empty meshbuf" << std::endl;
bool transparent = (rnd && rnd->isTransparent());
if (transparent == is_transparent_pass) {
if (buf->getVertexCount() == 0)
errorstream << "Block [" << analyze_block(block)
<< "] contains an empty meshbuf" << std::endl;
material.setFlag(video::EMF_TRILINEAR_FILTER, m_cache_trilinear_filter);
material.setFlag(video::EMF_BILINEAR_FILTER, m_cache_bilinear_filter);
material.setFlag(video::EMF_ANISOTROPIC_FILTER, m_cache_anistropic_filter);
material.setFlag(video::EMF_WIREFRAME, m_control.show_wireframe);
material.setFlag(video::EMF_TRILINEAR_FILTER,
m_cache_trilinear_filter);
material.setFlag(video::EMF_BILINEAR_FILTER,
m_cache_bilinear_filter);
material.setFlag(video::EMF_ANISOTROPIC_FILTER,
m_cache_anistropic_filter);
material.setFlag(video::EMF_WIREFRAME,
m_control.show_wireframe);
drawbufs.add(buf);
drawbufs.add(buf, layer);
}
}
}
}

61
src/content_mapblock.cpp
View File

@ -78,17 +78,19 @@ void MapblockMeshGenerator::useTile(int index, bool disable_backface_culling)
{
tile = getNodeTileN(n, p, index, data);
if (!data->m_smooth_lighting)
color = encode_light_and_color(light, tile.color, f->light_source);
if (disable_backface_culling)
tile.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
color = encode_light(light, f->light_source);
for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
tile.layers[layer].material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
if (disable_backface_culling)
tile.layers[layer].material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
}
}
void MapblockMeshGenerator::useDefaultTile(bool set_color)
{
tile = getNodeTile(n, p, v3s16(0, 0, 0), data);
if (set_color && !data->m_smooth_lighting)
color = encode_light_and_color(light, tile.color, f->light_source);
color = encode_light(light, f->light_source);
}
TileSpec MapblockMeshGenerator::getTile(const v3s16& direction)
@ -106,7 +108,7 @@ void MapblockMeshGenerator::drawQuad(v3f *coords, const v3s16 &normal)
vertices[j].Pos = coords[j] + origin;
vertices[j].Normal = normal2;
if (data->m_smooth_lighting)
vertices[j].Color = blendLight(coords[j], tile.color);
vertices[j].Color = blendLight(coords[j]);
else
vertices[j].Color = color;
if (shade_face)
@ -137,8 +139,7 @@ void MapblockMeshGenerator::drawCuboid(const aabb3f &box,
video::SColor colors[6];
if (!data->m_smooth_lighting) {
for (int face = 0; face != 6; ++face) {
int tileindex = MYMIN(face, tilecount - 1);
colors[face] = encode_light_and_color(light, tiles[tileindex].color, f->light_source);
colors[face] = encode_light(light, f->light_source);
}
if (!f->light_source) {
applyFacesShading(colors[0], v3f(0, 1, 0));
@ -240,9 +241,8 @@ void MapblockMeshGenerator::drawCuboid(const aabb3f &box,
if (data->m_smooth_lighting) {
for (int j = 0; j < 24; ++j) {
int tileindex = MYMIN(j / 4, tilecount - 1);
vertices[j].Color = encode_light_and_color(lights[light_indices[j]],
tiles[tileindex].color, f->light_source);
vertices[j].Color = encode_light(lights[light_indices[j]],
f->light_source);
if (!f->light_source)
applyFacesShading(vertices[j].Color, vertices[j].Normal);
}
@ -289,17 +289,16 @@ u16 MapblockMeshGenerator::blendLight(const v3f &vertex_pos)
// Calculates vertex color to be used in mapblock mesh
// vertex_pos - vertex position in the node (coordinates are clamped to [0.0, 1.0] or so)
// tile_color - node's tile color
video::SColor MapblockMeshGenerator::blendLight(const v3f &vertex_pos,
video::SColor tile_color)
video::SColor MapblockMeshGenerator::blendLightColor(const v3f &vertex_pos)
{
u16 light = blendLight(vertex_pos);
return encode_light_and_color(light, tile_color, f->light_source);
return encode_light(light, f->light_source);
}
video::SColor MapblockMeshGenerator::blendLight(const v3f &vertex_pos,
const v3f &vertex_normal, video::SColor tile_color)
video::SColor MapblockMeshGenerator::blendLightColor(const v3f &vertex_pos,
const v3f &vertex_normal)
{
video::SColor color = blendLight(vertex_pos, tile_color);
video::SColor color = blendLight(vertex_pos);
if (!f->light_source)
applyFacesShading(color, vertex_normal);
return color;
@ -367,8 +366,13 @@ static TileSpec getSpecialTile(const ContentFeatures &f,
const MapNode &n, u8 i)
{
TileSpec copy = f.special_tiles[i];
if (!copy.has_color)
n.getColor(f, &copy.color);
for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) {
TileLayer *layer = &copy.layers[layernum];
if (layer->texture_id == 0)
continue;
if (!layer->has_color)
n.getColor(f, &(layer->color));
}
return copy;
}
@ -395,8 +399,8 @@ void MapblockMeshGenerator::prepareLiquidNodeDrawing(bool flowing)
light = getInteriorLight(ntop, 0, nodedef);
}
color_liquid_top = encode_light_and_color(light, tile_liquid_top.color, f->light_source);
color = encode_light_and_color(light, tile_liquid.color, f->light_source);
color_liquid_top = encode_light(light, f->light_source);
color = encode_light(light, f->light_source);
}
void MapblockMeshGenerator::getLiquidNeighborhood(bool flowing)
@ -547,7 +551,7 @@ void MapblockMeshGenerator::drawLiquidSides(bool flowing)
else
pos.Y = !top_is_same_liquid ? corner_levels[base.Z][base.X] : 0.5 * BS;
if (data->m_smooth_lighting)
color = blendLight(pos, tile_liquid.color);
color = blendLightColor(pos);
pos += origin;
vertices[j] = video::S3DVertex(pos.X, pos.Y, pos.Z, 0, 0, 0, color, vertex.u, vertex.v);
};
@ -574,7 +578,7 @@ void MapblockMeshGenerator::drawLiquidTop(bool flowing)
int w = corner_resolve[i][1];
vertices[i].Pos.Y += corner_levels[w][u];
if (data->m_smooth_lighting)
vertices[i].Color = blendLight(vertices[i].Pos, tile_liquid_top.color);
vertices[i].Color = blendLightColor(vertices[i].Pos);
vertices[i].Pos += origin;
}
@ -659,7 +663,9 @@ void MapblockMeshGenerator::drawGlasslikeFramedNode()
tiles[face] = getTile(g_6dirs[face]);
TileSpec glass_tiles[6];
if (tiles[0].texture && tiles[3].texture && tiles[4].texture) {
if (tiles[1].layers[0].texture &&
tiles[2].layers[0].texture &&
tiles[3].layers[0].texture) {
glass_tiles[0] = tiles[4];
glass_tiles[1] = tiles[0];
glass_tiles[2] = tiles[4];
@ -763,7 +769,7 @@ void MapblockMeshGenerator::drawGlasslikeFramedNode()
// Optionally render internal liquid level defined by param2
// Liquid is textured with 1 tile defined in nodedef 'special_tiles'
if (param2 > 0 && f->param_type_2 == CPT2_GLASSLIKE_LIQUID_LEVEL &&
f->special_tiles[0].texture) {
f->special_tiles[0].layers[0].texture) {
// Internal liquid level has param2 range 0 .. 63,
// convert it to -0.5 .. 0.5
float vlev = (param2 / 63.0) * 2.0 - 1.0;
@ -998,7 +1004,8 @@ void MapblockMeshGenerator::drawFencelikeNode()
{
useDefaultTile(false);
TileSpec tile_nocrack = tile;
tile_nocrack.material_flags &= ~MATERIAL_FLAG_CRACK;
for (int layer = 0; layer < MAX_TILE_LAYERS; layer++)
tile_nocrack.layers[layer].material_flags &= ~MATERIAL_FLAG_CRACK;
// Put wood the right way around in the posts
TileSpec tile_rot = tile;
@ -1253,7 +1260,7 @@ void MapblockMeshGenerator::drawMeshNode()
// vertex right here.
for (int k = 0; k < vertex_count; k++) {
video::S3DVertex &vertex = vertices[k];
vertex.Color = blendLight(vertex.Pos, vertex.Normal, tile.color);
vertex.Color = blendLightColor(vertex.Pos, vertex.Normal);
vertex.Pos += origin;
}
collector->append(tile, vertices, vertex_count,

4
src/content_mapblock.h
View File

@ -60,8 +60,8 @@ public:
// lighting
void getSmoothLightFrame();
u16 blendLight(const v3f &vertex_pos);
video::SColor blendLight(const v3f &vertex_pos, video::SColor tile_color);
video::SColor blendLight(const v3f &vertex_pos, const v3f &vertex_normal, video::SColor tile_color);
video::SColor blendLightColor(const v3f &vertex_pos);
video::SColor blendLightColor(const v3f &vertex_pos, const v3f &vertex_normal);
void useTile(int index, bool disable_backface_culling);
void useDefaultTile(bool set_color = true);

5
src/hud.cpp
View File

@ -687,8 +687,9 @@ void drawItemStack(video::IVideoDriver *driver,
assert(buf->getHardwareMappingHint_Vertex() == scene::EHM_NEVER);
video::SColor c = basecolor;
if (imesh->buffer_colors.size() > j) {
std::pair<bool, video::SColor> p = imesh->buffer_colors[j];
c = p.first ? p.second : basecolor;
ItemPartColor *p = &imesh->buffer_colors[j];
if (p->override_base)
c = p->color;
}
colorizeMeshBuffer(buf, &c);
video::SMaterial &material = buf->getMaterial();

529
src/mapblock_mesh.cpp
View File

@ -323,7 +323,7 @@ void final_color_blend(video::SColor *result,
video::SColorf dayLight;
get_sunlight_color(&dayLight, daynight_ratio);
final_color_blend(result,
encode_light_and_color(light, video::SColor(0xFFFFFFFF), 0), dayLight);
encode_light(light, 0), dayLight);
}
void final_color_blend(video::SColor *result,
@ -422,12 +422,19 @@ static void getNodeVertexDirs(v3s16 dir, v3s16 *vertex_dirs)
struct FastFace
{
TileSpec tile;
TileLayer layer;
video::S3DVertex vertices[4]; // Precalculated vertices
/*!
* The face is divided into two triangles. If this is true,
* vertices 0 and 2 are connected, othervise vertices 1 and 3
* are connected.
*/
bool vertex_0_2_connected;
u8 layernum;
};
static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3,
v3f p, v3s16 dir, v3f scale, std::vector<FastFace> &dest)
v3f p, v3s16 dir, v3f scale, std::vector<FastFace> &dest)
{
// Position is at the center of the cube.
v3f pos = p * BS;
@ -577,27 +584,50 @@ static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3,
v3f normal(dir.X, dir.Y, dir.Z);
dest.push_back(FastFace());
FastFace& face = *dest.rbegin();
u16 li[4] = { li0, li1, li2, li3 };
u16 day[4];
u16 night[4];
for (u8 i = 0; i < 4; i++) {
day[i] = li[i] >> 8;
night[i] = li[i] & 0xFF;
}
bool vertex_0_2_connected = abs(day[0] - day[2]) + abs(night[0] - night[2])
< abs(day[1] - day[3]) + abs(night[1] - night[3]);
v2f32 f[4] = {
core::vector2d<f32>(x0 + w * abs_scale, y0 + h),
core::vector2d<f32>(x0, y0 + h),
core::vector2d<f32>(x0, y0),
core::vector2d<f32>(x0 + w * abs_scale, y0) };
for (u8 i = 0; i < 4; i++) {
video::SColor c = encode_light_and_color(li[i], tile.color,
tile.emissive_light);
if (!tile.emissive_light)
applyFacesShading(c, normal);
for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) {
TileLayer *layer = &tile.layers[layernum];
if (layer->texture_id == 0)
continue;
face.vertices[i] = video::S3DVertex(vertex_pos[i], normal, c, f[i]);
dest.push_back(FastFace());
FastFace& face = *dest.rbegin();
for (u8 i = 0; i < 4; i++) {
video::SColor c = encode_light(li[i], tile.emissive_light);
if (!tile.emissive_light)
applyFacesShading(c, normal);
face.vertices[i] = video::S3DVertex(vertex_pos[i], normal, c, f[i]);
}
/*
Revert triangles for nicer looking gradient if the
brightness of vertices 1 and 3 differ less than
the brightness of vertices 0 and 2.
*/
face.vertex_0_2_connected = vertex_0_2_connected;
face.layer = *layer;
face.layernum = layernum;
}
face.tile = tile;
}
/*
@ -663,13 +693,20 @@ TileSpec getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data)
{
INodeDefManager *ndef = data->m_client->ndef();
const ContentFeatures &f = ndef->get(mn);
TileSpec spec = f.tiles[tileindex];
if (!spec.has_color)
mn.getColor(f, &spec.color);
TileSpec tile = f.tiles[tileindex];
TileLayer *top_layer = NULL;
for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) {
TileLayer *layer = &tile.layers[layernum];
if (layer->texture_id == 0)
continue;
top_layer = layer;
if (!layer->has_color)
mn.getColor(f, &(layer->color));
}
// Apply temporary crack
if (p == data->m_crack_pos_relative)
spec.material_flags |= MATERIAL_FLAG_CRACK;
return spec;
top_layer->material_flags |= MATERIAL_FLAG_CRACK;
return tile;
}
/*
@ -732,10 +769,9 @@ TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data)
};
u16 tile_index=facedir*16 + dir_i;
TileSpec spec = getNodeTileN(mn, p, dir_to_tile[tile_index], data);
spec.rotation=dir_to_tile[tile_index + 1];
spec.texture = data->m_client->tsrc()->getTexture(spec.texture_id);
return spec;
TileSpec tile = getNodeTileN(mn, p, dir_to_tile[tile_index], data);
tile.rotation = dir_to_tile[tile_index + 1];
return tile;
}
static void getTileInfo(
@ -800,7 +836,9 @@ static void getTileInfo(
// eg. water and glass
if (equivalent)
tile.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++)
tile.layers[layernum].material_flags |=
MATERIAL_FLAG_BACKFACE_CULLING;
if (data->m_smooth_lighting == false)
{
@ -880,12 +918,7 @@ static void updateFastFaceRow(
&& next_lights[1] == lights[1]
&& next_lights[2] == lights[2]
&& next_lights[3] == lights[3]
&& next_tile == tile
&& tile.rotation == 0
&& (tile.material_flags & MATERIAL_FLAG_TILEABLE_HORIZONTAL)
&& (tile.material_flags & MATERIAL_FLAG_TILEABLE_VERTICAL)
&& tile.color == next_tile.color
&& tile.emissive_light == next_tile.emissive_light) {
&& next_tile.isTileable(tile)) {
next_is_different = false;
continuous_tiles_count++;
}
@ -988,7 +1021,6 @@ static void updateAllFastFaceRows(MeshMakeData *data,
*/
MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
m_mesh(new scene::SMesh()),
m_minimap_mapblock(NULL),
m_client(data->m_client),
m_driver(m_client->tsrc()->getDevice()->getVideoDriver()),
@ -1000,6 +1032,8 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
m_last_daynight_ratio((u32) -1),
m_daynight_diffs()
{
for (int m = 0; m < MAX_TILE_LAYERS; m++)
m_mesh[m] = new scene::SMesh();
m_enable_shaders = data->m_use_shaders;
m_use_tangent_vertices = data->m_use_tangent_vertices;
m_enable_vbo = g_settings->getBool("enable_vbo");
@ -1048,23 +1082,14 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
const u16 indices[] = {0,1,2,2,3,0};
const u16 indices_alternate[] = {0,1,3,2,3,1};
if(f.tile.texture == NULL)
if (f.layer.texture == NULL)
continue;
const u16 *indices_p = indices;
const u16 *indices_p =
f.vertex_0_2_connected ? indices : indices_alternate;
/*
Revert triangles for nicer looking gradient if the
brightness of vertices 1 and 3 differ less than
the brightness of vertices 0 and 2.
*/
if (fabs(f.vertices[0].Color.getLuminance()
- f.vertices[2].Color.getLuminance())
> fabs(f.vertices[1].Color.getLuminance()
- f.vertices[3].Color.getLuminance()))
indices_p = indices_alternate;
collector.append(f.tile, f.vertices, 4, indices_p, 6);
collector.append(f.layer, f.vertices, 4, indices_p, 6,
f.layernum);
}
}
@ -1081,146 +1106,151 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
generator.generate();
}
collector.applyTileColors();
/*
Convert MeshCollector to SMesh
*/
for(u32 i = 0; i < collector.prebuffers.size(); i++)
{
PreMeshBuffer &p = collector.prebuffers[i];
// Generate animation data
// - Cracks
if(p.tile.material_flags & MATERIAL_FLAG_CRACK)
for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
for(u32 i = 0; i < collector.prebuffers[layer].size(); i++)
{
// Find the texture name plus ^[crack:N:
std::ostringstream os(std::ios::binary);
os<<m_tsrc->getTextureName(p.tile.texture_id)<<"^[crack";
if(p.tile.material_flags & MATERIAL_FLAG_CRACK_OVERLAY)
os<<"o"; // use ^[cracko
os<<":"<<(u32)p.tile.animation_frame_count<<":";
m_crack_materials.insert(std::make_pair(i, os.str()));
// Replace tile texture with the cracked one
p.tile.texture = m_tsrc->getTextureForMesh(
os.str()+"0",
&p.tile.texture_id);
}
// - Texture animation
if (p.tile.material_flags & MATERIAL_FLAG_ANIMATION) {
// Add to MapBlockMesh in order to animate these tiles
m_animation_tiles[i] = p.tile;
m_animation_frames[i] = 0;
if(g_settings->getBool("desynchronize_mapblock_texture_animation")){
// Get starting position from noise
m_animation_frame_offsets[i] = 100000 * (2.0 + noise3d(
data->m_blockpos.X, data->m_blockpos.Y,
data->m_blockpos.Z, 0));
} else {
// Play all synchronized
m_animation_frame_offsets[i] = 0;
}
// Replace tile texture with the first animation frame
FrameSpec animation_frame = p.tile.frames[0];
p.tile.texture = animation_frame.texture;
}
PreMeshBuffer &p = collector.prebuffers[layer][i];
if (!m_enable_shaders) {
// Extract colors for day-night animation
// Dummy sunlight to handle non-sunlit areas
video::SColorf sunlight;
get_sunlight_color(&sunlight, 0);
u32 vertex_count =
m_use_tangent_vertices ?
p.tangent_vertices.size() : p.vertices.size();
for (u32 j = 0; j < vertex_count; j++) {
video::SColor *vc;
if (m_use_tangent_vertices) {
vc = &p.tangent_vertices[j].Color;
// Generate animation data
// - Cracks
if(p.layer.material_flags & MATERIAL_FLAG_CRACK)
{
// Find the texture name plus ^[crack:N:
std::ostringstream os(std::ios::binary);
os<<m_tsrc->getTextureName(p.layer.texture_id)<<"^[crack";
if(p.layer.material_flags & MATERIAL_FLAG_CRACK_OVERLAY)
os<<"o"; // use ^[cracko
os<<":"<<(u32)p.layer.animation_frame_count<<":";
m_crack_materials.insert(std::make_pair(std::pair<u8, u32>(layer, i), os.str()));
// Replace tile texture with the cracked one
p.layer.texture = m_tsrc->getTextureForMesh(
os.str()+"0",
&p.layer.texture_id);
}
// - Texture animation
if (p.layer.material_flags & MATERIAL_FLAG_ANIMATION) {
// Add to MapBlockMesh in order to animate these tiles
m_animation_tiles[std::pair<u8, u32>(layer, i)] = p.layer;
m_animation_frames[std::pair<u8, u32>(layer, i)] = 0;
if(g_settings->getBool("desynchronize_mapblock_texture_animation")){
// Get starting position from noise
m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] = 100000 * (2.0 + noise3d(
data->m_blockpos.X, data->m_blockpos.Y,
data->m_blockpos.Z, 0));
} else {
vc = &p.vertices[j].Color;
// Play all synchronized
m_animation_frame_offsets[std::pair<u8, u32>(layer, i)] = 0;
}
video::SColor copy(*vc);
if (vc->getAlpha() == 0) // No sunlight - no need to animate
final_color_blend(vc, copy, sunlight); // Finalize color
else // Record color to animate
m_daynight_diffs[i][j] = copy;
// Replace tile texture with the first animation frame
FrameSpec animation_frame = p.layer.frames[0];
p.layer.texture = animation_frame.texture;
}
// The sunlight ratio has been stored,
// delete alpha (for the final rendering).
vc->setAlpha(255);
if (!m_enable_shaders) {
// Extract colors for day-night animation
// Dummy sunlight to handle non-sunlit areas
video::SColorf sunlight;
get_sunlight_color(&sunlight, 0);
u32 vertex_count =
m_use_tangent_vertices ?
p.tangent_vertices.size() : p.vertices.size();
for (u32 j = 0; j < vertex_count; j++) {
video::SColor *vc;
if (m_use_tangent_vertices) {
vc = &p.tangent_vertices[j].Color;
} else {
vc = &p.vertices[j].Color;
}
video::SColor copy(*vc);
if (vc->getAlpha() == 0) // No sunlight - no need to animate
final_color_blend(vc, copy, sunlight); // Finalize color
else // Record color to animate
m_daynight_diffs[std::pair<u8, u32>(layer, i)][j] = copy;
// The sunlight ratio has been stored,
// delete alpha (for the final rendering).
vc->setAlpha(255);
}
}
// Create material
video::SMaterial material;
material.setFlag(video::EMF_LIGHTING, false);
material.setFlag(video::EMF_BACK_FACE_CULLING, true);
material.setFlag(video::EMF_BILINEAR_FILTER, false);
material.setFlag(video::EMF_FOG_ENABLE, true);
material.setTexture(0, p.layer.texture);
if (m_enable_shaders) {
material.MaterialType = m_shdrsrc->getShaderInfo(p.layer.shader_id).material;
p.layer.applyMaterialOptionsWithShaders(material);
if (p.layer.normal_texture) {
material.setTexture(1, p.layer.normal_texture);
}
material.setTexture(2, p.layer.flags_texture);
} else {
p.layer.applyMaterialOptions(material);
}
scene::SMesh *mesh = (scene::SMesh *)m_mesh[layer];
// Create meshbuffer, add to mesh
if (m_use_tangent_vertices) {
scene::SMeshBufferTangents *buf = new scene::SMeshBufferTangents();
// Set material
buf->Material = material;
// Add to mesh
mesh->addMeshBuffer(buf);
// Mesh grabbed it
buf->drop();
buf->append(&p.tangent_vertices[0], p.tangent_vertices.size(),
&p.indices[0], p.indices.size());
} else {
scene::SMeshBuffer *buf = new scene::SMeshBuffer();
// Set material
buf->Material = material;
// Add to mesh
mesh->addMeshBuffer(buf);
// Mesh grabbed it
buf->drop();
buf->append(&p.vertices[0], p.vertices.size(),
&p.indices[0], p.indices.size());
}
}
// Create material
video::SMaterial material;
material.setFlag(video::EMF_LIGHTING, false);
material.setFlag(video::EMF_BACK_FACE_CULLING, true);
material.setFlag(video::EMF_BILINEAR_FILTER, false);
material.setFlag(video::EMF_FOG_ENABLE, true);
material.setTexture(0, p.tile.texture);
if (m_enable_shaders) {
material.MaterialType = m_shdrsrc->getShaderInfo(p.tile.shader_id).material;
p.tile.applyMaterialOptionsWithShaders(material);
if (p.tile.normal_texture) {
material.setTexture(1, p.tile.normal_texture);
}
material.setTexture(2, p.tile.flags_texture);
} else {
p.tile.applyMaterialOptions(material);
}
/*
Do some stuff to the mesh
*/
m_camera_offset = camera_offset;
translateMesh(m_mesh[layer],
intToFloat(data->m_blockpos * MAP_BLOCKSIZE - camera_offset, BS));
scene::SMesh *mesh = (scene::SMesh *)m_mesh;
// Create meshbuffer, add to mesh
if (m_use_tangent_vertices) {
scene::SMeshBufferTangents *buf = new scene::SMeshBufferTangents();
// Set material
buf->Material = material;
// Add to mesh
mesh->addMeshBuffer(buf);
// Mesh grabbed it
buf->drop();
buf->append(&p.tangent_vertices[0], p.tangent_vertices.size(),
&p.indices[0], p.indices.size());
} else {
scene::SMeshBuffer *buf = new scene::SMeshBuffer();
// Set material
buf->Material = material;
// Add to mesh
mesh->addMeshBuffer(buf);
// Mesh grabbed it
buf->drop();
buf->append(&p.vertices[0], p.vertices.size(),
&p.indices[0], p.indices.size());
scene::IMeshManipulator* meshmanip =
m_client->getSceneManager()->getMeshManipulator();
meshmanip->recalculateTangents(m_mesh[layer], true, false, false);
}
}
/*
Do some stuff to the mesh
*/
m_camera_offset = camera_offset;
translateMesh(m_mesh,
intToFloat(data->m_blockpos * MAP_BLOCKSIZE - camera_offset, BS));
if (m_use_tangent_vertices) {
scene::IMeshManipulator* meshmanip =
m_client->getSceneManager()->getMeshManipulator();
meshmanip->recalculateTangents(m_mesh, true, false, false);
}
if (m_mesh)
{
if (m_mesh[layer])
{
#if 0
// Usually 1-700 faces and 1-7 materials
std::cout<<"Updated MapBlock has "<<fastfaces_new.size()<<" faces "
<<"and uses "<<m_mesh->getMeshBufferCount()
<<" materials (meshbuffers)"<<std::endl;
// Usually 1-700 faces and 1-7 materials
std::cout<<"Updated MapBlock has "<<fastfaces_new.size()<<" faces "
<<"and uses "<<m_mesh[layer]->getMeshBufferCount()
<<" materials (meshbuffers)"<<std::endl;
#endif
// Use VBO for mesh (this just would set this for ever buffer)
if (m_enable_vbo) {
m_mesh->setHardwareMappingHint(scene::EHM_STATIC);
// Use VBO for mesh (this just would set this for ever buffer)
if (m_enable_vbo) {
m_mesh[layer]->setHardwareMappingHint(scene::EHM_STATIC);
}
}
}
@ -1235,14 +1265,15 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
MapBlockMesh::~MapBlockMesh()
{
if (m_enable_vbo && m_mesh) {
for (u32 i = 0; i < m_mesh->getMeshBufferCount(); i++) {
scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i);
m_driver->removeHardwareBuffer(buf);
}
for (int m = 0; m < MAX_TILE_LAYERS; m++) {
if (m_enable_vbo && m_mesh[m])
for (u32 i = 0; i < m_mesh[m]->getMeshBufferCount(); i++) {
scene::IMeshBuffer *buf = m_mesh[m]->getMeshBuffer(i);
m_driver->removeHardwareBuffer(buf);
}
m_mesh[m]->drop();
m_mesh[m] = NULL;
}
m_mesh->drop();
m_mesh = NULL;
delete m_minimap_mapblock;
}
@ -1259,9 +1290,10 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat
// Cracks
if(crack != m_last_crack)
{
for (UNORDERED_MAP<u32, std::string>::iterator i = m_crack_materials.begin();
i != m_crack_materials.end(); ++i) {
scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first);
for (std::map<std::pair<u8, u32>, std::string>::iterator i =
m_crack_materials.begin(); i != m_crack_materials.end(); ++i) {
scene::IMeshBuffer *buf = m_mesh[i->first.first]->
getMeshBuffer(i->first.second);
std::string basename = i->second;
// Create new texture name from original
@ -1274,10 +1306,10 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat
// If the current material is also animated,
// update animation info
UNORDERED_MAP<u32, TileSpec>::iterator anim_iter =
m_animation_tiles.find(i->first);
std::map<std::pair<u8, u32>, TileLayer>::iterator anim_iter =
m_animation_tiles.find(i->first);
if (anim_iter != m_animation_tiles.end()){
TileSpec &tile = anim_iter->second;
TileLayer &tile = anim_iter->second;
tile.texture = new_texture;
tile.texture_id = new_texture_id;
// force animation update
@ -1289,9 +1321,9 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat
}
// Texture animation
for (UNORDERED_MAP<u32, TileSpec>::iterator i = m_animation_tiles.begin();
i != m_animation_tiles.end(); ++i) {
const TileSpec &tile = i->second;
for (std::map<std::pair<u8, u32>, TileLayer>::iterator i =
m_animation_tiles.begin(); i != m_animation_tiles.end(); ++i) {
const TileLayer &tile = i->second;
// Figure out current frame
int frameoffset = m_animation_frame_offsets[i->first];
int frame = (int)(time * 1000 / tile.animation_frame_length_ms
@ -1302,7 +1334,8 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat
m_animation_frames[i->first] = frame;
scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first);
scene::IMeshBuffer *buf = m_mesh[i->first.first]->
getMeshBuffer(i->first.second);
FrameSpec animation_frame = tile.frames[frame];
buf->getMaterial().setTexture(0, animation_frame.texture);
@ -1318,22 +1351,24 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat
if(!m_enable_shaders && (daynight_ratio != m_last_daynight_ratio))
{
// Force reload mesh to VBO
if (m_enable_vbo) {
m_mesh->setDirty();
}
if (m_enable_vbo)
for (int m = 0; m < MAX_TILE_LAYERS; m++)
m_mesh[m]->setDirty();
video::SColorf day_color;
get_sunlight_color(&day_color, daynight_ratio);
for(std::map<u32, std::map<u32, video::SColor > >::iterator
for(std::map<std::pair<u8, u32>, std::map<u32, video::SColor > >::iterator
i = m_daynight_diffs.begin();
i != m_daynight_diffs.end(); ++i)
{
scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first);
scene::IMeshBuffer *buf = m_mesh[i->first.first]->
getMeshBuffer(i->first.second);
video::S3DVertex *vertices = (video::S3DVertex *)buf->getVertices();
for(std::map<u32, video::SColor >::iterator
j = i->second.begin();
j != i->second.end(); ++j)
{
final_color_blend(&(vertices[j->first].Color), j->second, day_color);
final_color_blend(&(vertices[j->first].Color),
j->second, day_color);
}
}
m_last_daynight_ratio = daynight_ratio;
@ -1345,9 +1380,12 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat
void MapBlockMesh::updateCameraOffset(v3s16 camera_offset)
{
if (camera_offset != m_camera_offset) {
translateMesh(m_mesh, intToFloat(m_camera_offset-camera_offset, BS));
if (m_enable_vbo) {
m_mesh->setDirty();
for (u8 layer = 0; layer < 2; layer++) {
translateMesh(m_mesh[layer],
intToFloat(m_camera_offset - camera_offset, BS));
if (m_enable_vbo) {
m_mesh[layer]->setDirty();
}
}
m_camera_offset = camera_offset;
}
@ -1360,16 +1398,30 @@ void MapBlockMesh::updateCameraOffset(v3s16 camera_offset)
void MeshCollector::append(const TileSpec &tile,
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices)
{
for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) {
const TileLayer *layer = &tile.layers[layernum];
if (layer->texture_id == 0)
continue;
append(*layer, vertices, numVertices, indices, numIndices,
layernum);
}
}
void MeshCollector::append(const TileLayer &layer,
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices, u8 layernum)
{
if (numIndices > 65535) {
dstream<<"FIXME: MeshCollector::append() called with numIndices="<<numIndices<<" (limit 65535)"<<std::endl;
return;
}
std::vector<PreMeshBuffer> *buffers = &prebuffers[layernum];
PreMeshBuffer *p = NULL;
for (u32 i = 0; i < prebuffers.size(); i++) {
PreMeshBuffer &pp = prebuffers[i];
if (pp.tile != tile)
for (u32 i = 0; i < buffers->size(); i++) {
PreMeshBuffer &pp = (*buffers)[i];
if (pp.layer != layer)
continue;
if (pp.indices.size() + numIndices > 65535)
continue;
@ -1380,9 +1432,9 @@ void MeshCollector::append(const TileSpec &tile,
if (p == NULL) {
PreMeshBuffer pp;
pp.tile = tile;
prebuffers.push_back(pp);
p = &prebuffers[prebuffers.size() - 1];
pp.layer = layer;
buffers->push_back(pp);
p = &(*buffers)[buffers->size() - 1];
}
u32 vertex_count;
@ -1416,16 +1468,31 @@ void MeshCollector::append(const TileSpec &tile,
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices,
v3f pos, video::SColor c, u8 light_source)
{
for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) {
const TileLayer *layer = &tile.layers[layernum];
if (layer->texture_id == 0)
continue;
append(*layer, vertices, numVertices, indices, numIndices, pos,
c, light_source, layernum);
}
}
void MeshCollector::append(const TileLayer &layer,
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices,
v3f pos, video::SColor c, u8 light_source, u8 layernum)
{
if (numIndices > 65535) {
dstream<<"FIXME: MeshCollector::append() called with numIndices="<<numIndices<<" (limit 65535)"<<std::endl;
return;
}
std::vector<PreMeshBuffer> *buffers = &prebuffers[layernum];
PreMeshBuffer *p = NULL;
for (u32 i = 0; i < prebuffers.size(); i++) {
PreMeshBuffer &pp = prebuffers[i];
if(pp.tile != tile)
for (u32 i = 0; i < buffers->size(); i++) {
PreMeshBuffer &pp = (*buffers)[i];
if(pp.layer != layer)
continue;
if(pp.indices.size() + numIndices > 65535)
continue;
@ -1436,9 +1503,9 @@ void MeshCollector::append(const TileSpec &tile,
if (p == NULL) {
PreMeshBuffer pp;
pp.tile = tile;
prebuffers.push_back(pp);
p = &prebuffers[prebuffers.size() - 1];
pp.layer = layer;
buffers->push_back(pp);
p = &(*buffers)[buffers->size() - 1];
}
video::SColor original_c = c;
@ -1473,14 +1540,49 @@ void MeshCollector::append(const TileSpec &tile,
}
}
video::SColor encode_light_and_color(u16 light, const video::SColor &color,
u8 emissive_light)
void MeshCollector::applyTileColors()
{
if (m_use_tangent_vertices)
for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
std::vector<PreMeshBuffer> *p = &prebuffers[layer];
for (std::vector<PreMeshBuffer>::iterator it = p->begin();
it != p->end(); ++it) {
video::SColor tc = it->layer.color;
if (tc == video::SColor(0xFFFFFFFF))
continue;
for (u32 index = 0; index < it->tangent_vertices.size(); index++) {
video::SColor *c = &it->tangent_vertices[index].Color;
c->set(c->getAlpha(), c->getRed() * tc.getRed() / 255,
c->getGreen() * tc.getGreen() / 255,
c->getBlue() * tc.getBlue() / 255);
}
}
}
else
for (int layer = 0; layer < MAX_TILE_LAYERS; layer++) {
std::vector<PreMeshBuffer> *p = &prebuffers[layer];
for (std::vector<PreMeshBuffer>::iterator it = p->begin();
it != p->end(); ++it) {
video::SColor tc = it->layer.color;
if (tc == video::SColor(0xFFFFFFFF))
continue;
for (u32 index = 0; index < it->vertices.size(); index++) {
video::SColor *c = &it->vertices[index].Color;
c->set(c->getAlpha(), c->getRed() * tc.getRed() / 255,
c->getGreen() * tc.getGreen() / 255,
c->getBlue() * tc.getBlue() / 255);
}
}
}
}
video::SColor encode_light(u16 light, u8 emissive_light)
{
// Get components
f32 day = (light & 0xff) / 255.0f;
f32 night = (light >> 8) / 255.0f;
u32 day = (light & 0xff);
u32 night = (light >> 8);
// Add emissive light
night += emissive_light * 0.01f;
night += emissive_light * 2.5f;
if (night > 255)
night = 255;
// Since we don't know if the day light is sunlight or
@ -1490,15 +1592,14 @@ video::SColor encode_light_and_color(u16 light, const video::SColor &color,
day = 0;
else
day = day - night;
f32 sum = day + night;
u32 sum = day + night;
// Ratio of sunlight:
float r;
u32 r;
if (sum > 0)
r = day / sum;
r = day * 255 / sum;
else
r = 0;
// Average light:
float b = (day + night) / 2;
return video::SColor(r * 255, b * color.getRed(), b * color.getGreen(),
b * color.getBlue());
return video::SColor(r, b, b, b);
}

57
src/mapblock_mesh.h
View File

@ -108,7 +108,12 @@ public:
scene::IMesh *getMesh()
{
return m_mesh;
return m_mesh[0];
}
scene::IMesh *getMesh(u8 layer)
{
return m_mesh[layer];
}
MinimapMapblock *moveMinimapMapblock()
@ -132,7 +137,7 @@ public:
void updateCameraOffset(v3s16 camera_offset);
private:
scene::IMesh *m_mesh;
scene::IMesh *m_mesh[MAX_TILE_LAYERS];
MinimapMapblock *m_minimap_mapblock;
Client *m_client;
video::IVideoDriver *m_driver;
@ -150,20 +155,23 @@ private:
// Animation info: cracks
// Last crack value passed to animate()
int m_last_crack;
// Maps mesh buffer (i.e. material) indices to base texture names
UNORDERED_MAP<u32, std::string> m_crack_materials;
// Maps mesh and mesh buffer (i.e. material) indices to base texture names
std::map<std::pair<u8, u32>, std::string> m_crack_materials;
// Animation info: texture animationi
// Maps meshbuffers to TileSpecs
UNORDERED_MAP<u32, TileSpec> m_animation_tiles;
UNORDERED_MAP<u32, int> m_animation_frames; // last animation frame
UNORDERED_MAP<u32, int> m_animation_frame_offsets;
// Maps mesh and mesh buffer indices to TileSpecs
// Keys are pairs of (mesh index, buffer index in the mesh)
std::map<std::pair<u8, u32>, TileLayer> m_animation_tiles;
std::map<std::pair<u8, u32>, int> m_animation_frames; // last animation frame
std::map<std::pair<u8, 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, stores pre-baked colors of sunlit vertices
std::map<u32, std::map<u32, video::SColor > > m_daynight_diffs;
// For each mesh and mesh buffer, stores pre-baked colors
// of sunlit vertices
// Keys are pairs of (mesh index, buffer index in the mesh)
std::map<std::pair<u8, u32>, std::map<u32, video::SColor > > m_daynight_diffs;
// Camera offset info -> do we have to translate the mesh?
v3s16 m_camera_offset;
@ -176,7 +184,7 @@ private:
*/
struct PreMeshBuffer
{
TileSpec tile;
TileLayer layer;
std::vector<u16> indices;
std::vector<video::S3DVertex> vertices;
std::vector<video::S3DVertexTangents> tangent_vertices;
@ -184,7 +192,7 @@ struct PreMeshBuffer
struct MeshCollector
{
std::vector<PreMeshBuffer> prebuffers;
std::vector<PreMeshBuffer> prebuffers[MAX_TILE_LAYERS];
bool m_use_tangent_vertices;
MeshCollector(bool use_tangent_vertices):
@ -193,27 +201,38 @@ struct MeshCollector
}
void append(const TileSpec &material,
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices);
void append(const TileLayer &material,
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices);
const u16 *indices, u32 numIndices, u8 layernum);
void append(const TileSpec &material,
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices, v3f pos,
video::SColor c, u8 light_source);
void append(const TileLayer &material,
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices,
v3f pos, video::SColor c, u8 light_source);
const u16 *indices, u32 numIndices, v3f pos,
video::SColor c, u8 light_source, u8 layernum);
/*!
* Colorizes all vertices in the collector.
*/
void applyTileColors();
};
/*!
* Encodes light and color of a node.
* Encodes light of a node.
* The result is not the final color, but a
* half-baked vertex color.
* You have to multiply the resulting color
* with the node's color.
*
* \param light the first 8 bits are day light,
* the last 8 bits are night light
* \param color the node's color
* \param emissive_light amount of light the surface emits,
* from 0 to LIGHT_SUN.
*/
video::SColor encode_light_and_color(u16 light, const video::SColor &color,
u8 emissive_light);
video::SColor encode_light(u16 light, u8 emissive_light);
// Compute light at node
u16 getInteriorLight(MapNode n, s32 increment, INodeDefManager *ndef);

80
src/mesh.cpp
View File

@ -385,48 +385,50 @@ void recalculateBoundingBox(scene::IMesh *src_mesh)
src_mesh->setBoundingBox(bbox);
}
scene::IMesh* cloneMesh(scene::IMesh *src_mesh)
scene::IMeshBuffer* cloneMeshBuffer(scene::IMeshBuffer *mesh_buffer)
{
scene::IMeshBuffer *clone = NULL;
switch (mesh_buffer->getVertexType()) {
case video::EVT_STANDARD: {
video::S3DVertex *v = (video::S3DVertex *) mesh_buffer->getVertices();
u16 *indices = (u16*) mesh_buffer->getIndices();
scene::SMeshBuffer *temp_buf = new scene::SMeshBuffer();
temp_buf->append(v, mesh_buffer->getVertexCount(), indices,
mesh_buffer->getIndexCount());
return temp_buf;
break;
}
case video::EVT_2TCOORDS: {
video::S3DVertex2TCoords *v =
(video::S3DVertex2TCoords *) mesh_buffer->getVertices();
u16 *indices = (u16*) mesh_buffer->getIndices();
scene::SMeshBufferTangents *temp_buf = new scene::SMeshBufferTangents();
temp_buf->append(v, mesh_buffer->getVertexCount(), indices,
mesh_buffer->getIndexCount());
break;
}
case video::EVT_TANGENTS: {
video::S3DVertexTangents *v =
(video::S3DVertexTangents *) mesh_buffer->getVertices();
u16 *indices = (u16*) mesh_buffer->getIndices();
scene::SMeshBufferTangents *temp_buf = new scene::SMeshBufferTangents();
temp_buf->append(v, mesh_buffer->getVertexCount(), indices,
mesh_buffer->getIndexCount());
break;
}
}
return clone;
}
scene::SMesh* cloneMesh(scene::IMesh *src_mesh)
{
scene::SMesh* dst_mesh = new scene::SMesh();
for (u16 j = 0; j < src_mesh->getMeshBufferCount(); j++) {
scene::IMeshBuffer *buf = src_mesh->getMeshBuffer(j);
switch (buf->getVertexType()) {
case video::EVT_STANDARD: {
video::S3DVertex *v =
(video::S3DVertex *) buf->getVertices();
u16 *indices = (u16*)buf->getIndices();
scene::SMeshBuffer *temp_buf = new scene::SMeshBuffer();
temp_buf->append(v, buf->getVertexCount(),
indices, buf->getIndexCount());
dst_mesh->addMeshBuffer(temp_buf);
temp_buf->drop();
break;
}
case video::EVT_2TCOORDS: {
video::S3DVertex2TCoords *v =
(video::S3DVertex2TCoords *) buf->getVertices();
u16 *indices = (u16*)buf->getIndices();
scene::SMeshBufferTangents *temp_buf =
new scene::SMeshBufferTangents();
temp_buf->append(v, buf->getVertexCount(),
indices, buf->getIndexCount());
dst_mesh->addMeshBuffer(temp_buf);
temp_buf->drop();
break;
}
case video::EVT_TANGENTS: {
video::S3DVertexTangents *v =
(video::S3DVertexTangents *) buf->getVertices();
u16 *indices = (u16*)buf->getIndices();
scene::SMeshBufferTangents *temp_buf =
new scene::SMeshBufferTangents();
temp_buf->append(v, buf->getVertexCount(),
indices, buf->getIndexCount());
dst_mesh->addMeshBuffer(temp_buf);
temp_buf->drop();
break;
}
}
scene::IMeshBuffer *temp_buf = cloneMeshBuffer(
src_mesh->getMeshBuffer(j));
dst_mesh->addMeshBuffer(temp_buf);
temp_buf->drop();
}
return dst_mesh;
}

7
src/mesh.h
View File

@ -82,11 +82,16 @@ void rotateMeshBy6dFacedir(scene::IMesh *mesh, int facedir);
void rotateMeshXYby (scene::IMesh *mesh, f64 degrees);
void rotateMeshXZby (scene::IMesh *mesh, f64 degrees);
void rotateMeshYZby (scene::IMesh *mesh, f64 degrees);
/*
* Clone the mesh buffer.
*/
scene::IMeshBuffer* cloneMeshBuffer(scene::IMeshBuffer *mesh_buffer);
/*
Clone the mesh.
*/
scene::IMesh* cloneMesh(scene::IMesh *src_mesh);
scene::SMesh* cloneMesh(scene::IMesh *src_mesh);
/*
Convert nodeboxes to mesh. Each tile goes into a different buffer.

4
src/network/networkprotocol.h
View File

@ -148,9 +148,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
Add node and tile color and palette
Fix plantlike visual_scale being applied squared and add compatibility
with pre-30 clients by sending sqrt(visual_scale)
PROTOCOL VERSION 31:
Add tile overlay
*/
#define LATEST_PROTOCOL_VERSION 30
#define LATEST_PROTOCOL_VERSION 31
// Server's supported network protocol range
#define SERVER_PROTOCOL_VERSION_MIN 24

36
src/nodedef.cpp
View File

@ -378,13 +378,13 @@ void ContentFeatures::reset()
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
{
if (protocol_version < 30) {
if (protocol_version < 31) {
serializeOld(os, protocol_version);
return;
}
// version
writeU8(os, 9);
writeU8(os, 10);
// general
os << serializeString(name);
@ -404,6 +404,8 @@ void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const
writeU8(os, 6);
for (u32 i = 0; i < 6; i++)
tiledef[i].serialize(os, protocol_version);
for (u32 i = 0; i < 6; i++)
tiledef_overlay[i].serialize(os, protocol_version);
writeU8(os, CF_SPECIAL_COUNT);
for (u32 i = 0; i < CF_SPECIAL_COUNT; i++) {
tiledef_special[i].serialize(os, protocol_version);
@ -492,7 +494,7 @@ void ContentFeatures::deSerialize(std::istream &is)
if (version < 9) {
deSerializeOld(is, version);
return;
} else if (version > 9) {
} else if (version > 10) {
throw SerializationError("unsupported ContentFeatures version");
}
@ -516,6 +518,9 @@ void ContentFeatures::deSerialize(std::istream &is)
throw SerializationError("unsupported tile count");
for (u32 i = 0; i < 6; i++)
tiledef[i].deSerialize(is, version, drawtype);
if (version >= 10)
for (u32 i = 0; i < 6; i++)
tiledef_overlay[i].deSerialize(is, version, drawtype);
if (readU8(is) != CF_SPECIAL_COUNT)
throw SerializationError("unsupported CF_SPECIAL_COUNT");
for (u32 i = 0; i < CF_SPECIAL_COUNT; i++)
@ -581,7 +586,7 @@ void ContentFeatures::deSerialize(std::istream &is)
}
#ifndef SERVER
void ContentFeatures::fillTileAttribs(ITextureSource *tsrc, TileSpec *tile,
void ContentFeatures::fillTileAttribs(ITextureSource *tsrc, TileLayer *tile,
TileDef *tiledef, u32 shader_id, bool use_normal_texture,
bool backface_culling, u8 material_type)
{
@ -774,14 +779,18 @@ void ContentFeatures::updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc
// Tiles (fill in f->tiles[])
for (u16 j = 0; j < 6; j++) {
fillTileAttribs(tsrc, &tiles[j], &tdef[j], tile_shader[j],
fillTileAttribs(tsrc, &tiles[j].layers[0], &tdef[j], tile_shader[j],
tsettings.use_normal_texture,
tiledef[j].backface_culling, material_type);
if (tiledef_overlay[j].name!="")
fillTileAttribs(tsrc, &tiles[j].layers[1], &tiledef_overlay[j],
tile_shader[j], tsettings.use_normal_texture,
tiledef[j].backface_culling, material_type);
}
// Special tiles (fill in f->special_tiles[])
for (u16 j = 0; j < CF_SPECIAL_COUNT; j++) {
fillTileAttribs(tsrc, &special_tiles[j], &tiledef_special[j],
fillTileAttribs(tsrc, &special_tiles[j].layers[0], &tiledef_special[j],
tile_shader[j], tsettings.use_normal_texture,
tiledef_special[j].backface_culling, material_type);
}
@ -1538,8 +1547,19 @@ void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version) const
if (protocol_version < 30 && drawtype == NDT_PLANTLIKE)
compatible_visual_scale = sqrt(visual_scale);
TileDef compatible_tiles[6];
for (u8 i = 0; i < 6; i++) {
compatible_tiles[i] = tiledef[i];
if (tiledef_overlay[i].name != "") {
std::stringstream s;
s << "(" << tiledef[i].name << ")^(" << tiledef_overlay[i].name
<< ")";
compatible_tiles[i].name = s.str();
}
}
// Protocol >= 24
if (protocol_version < 30) {
if (protocol_version < 31) {
writeU8(os, protocol_version < 27 ? 7 : 8);
os << serializeString(name);
@ -1553,7 +1573,7 @@ void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version) const
writeF1000(os, compatible_visual_scale);
writeU8(os, 6);
for (u32 i = 0; i < 6; i++)
tiledef[i].serialize(os, protocol_version);
compatible_tiles[i].serialize(os, protocol_version);
writeU8(os, CF_SPECIAL_COUNT);
for (u32 i = 0; i < CF_SPECIAL_COUNT; i++)
tiledef_special[i].serialize(os, protocol_version);

4
src/nodedef.h
View File

@ -280,6 +280,8 @@ struct ContentFeatures
#endif
float visual_scale; // Misc. scale parameter
TileDef tiledef[6];
// These will be drawn over the base tiles.
TileDef tiledef_overlay[6];
TileDef tiledef_special[CF_SPECIAL_COUNT]; // eg. flowing liquid
// If 255, the node is opaque.
// Otherwise it uses texture alpha.
@ -405,7 +407,7 @@ struct ContentFeatures
}
#ifndef SERVER
void fillTileAttribs(ITextureSource *tsrc, TileSpec *tile, TileDef *tiledef,
void fillTileAttribs(ITextureSource *tsrc, TileLayer *tile, TileDef *tiledef,
u32 shader_id, bool use_normal_texture, bool backface_culling,
u8 material_type);
void updateTextures(ITextureSource *tsrc, IShaderSource *shdsrc,

2
src/particles.cpp
View File

@ -620,7 +620,7 @@ void ParticleManager::addNodeParticle(IGameDef* gamedef,
{
// Texture
u8 texid = myrand_range(0, 5);
const TileSpec &tile = f.tiles[texid];
const TileLayer &tile = f.tiles[texid].layers[0];
video::ITexture *texture;
struct TileAnimationParams anim;
anim.type = TAT_NONE;

28
src/script/common/c_content.cpp
View File

@ -426,6 +426,34 @@ ContentFeatures read_content_features(lua_State *L, int index)
}
lua_pop(L, 1);
// overlay_tiles = {}
lua_getfield(L, index, "overlay_tiles");
if (lua_istable(L, -1)) {
int table = lua_gettop(L);
lua_pushnil(L);
int i = 0;
while (lua_next(L, table) != 0) {
// Read tiledef from value
f.tiledef_overlay[i] = read_tiledef(L, -1, f.drawtype);
// removes value, keeps key for next iteration
lua_pop(L, 1);
i++;
if (i == 6) {
lua_pop(L, 1);
break;
}
}
// Copy last value to all remaining textures
if (i >= 1) {
TileDef lasttile = f.tiledef_overlay[i - 1];
while (i < 6) {
f.tiledef_overlay[i] = lasttile;
i++;
}
}
}
lua_pop(L, 1);
// special_tiles = {}
lua_getfield(L, index, "special_tiles");
// If nil, try the deprecated name "special_materials" instead

188
src/wieldmesh.cpp
View File

@ -235,27 +235,16 @@ WieldMeshSceneNode::~WieldMeshSceneNode()
g_extrusion_mesh_cache = NULL;
}
void WieldMeshSceneNode::setCube(const TileSpec tiles[6],
void WieldMeshSceneNode::setCube(const ContentFeatures &f,
v3f wield_scale, ITextureSource *tsrc)
{
scene::IMesh *cubemesh = g_extrusion_mesh_cache->createCube();
changeToMesh(cubemesh);
scene::SMesh *copy = cloneMesh(cubemesh);
cubemesh->drop();
postProcessNodeMesh(copy, f, false, true, &m_material_type, &m_colors);
changeToMesh(copy);
copy->drop();
m_meshnode->setScale(wield_scale * WIELD_SCALE_FACTOR);
// Customize materials
for (u32 i = 0; i < m_meshnode->getMaterialCount(); ++i) {
assert(i < 6);
video::SMaterial &material = m_meshnode->getMaterial(i);
if (tiles[i].animation_frame_count == 1) {
material.setTexture(0, tiles[i].texture);
} else {
FrameSpec animation_frame = tiles[i].frames[0];
material.setTexture(0, animation_frame.texture);
}
tiles[i].applyMaterialOptions(material);
}
}
void WieldMeshSceneNode::setExtruded(const std::string &imagename,
@ -274,8 +263,10 @@ void WieldMeshSceneNode::setExtruded(const std::string &imagename,
dim = core::dimension2d<u32>(dim.Width, frame_height);
}
scene::IMesh *mesh = g_extrusion_mesh_cache->create(dim);
changeToMesh(mesh);
scene::SMesh *copy = cloneMesh(mesh);
mesh->drop();
changeToMesh(copy);
copy->drop();
m_meshnode->setScale(wield_scale * WIELD_SCALE_FACTOR_EXTRUDED);
@ -321,12 +312,12 @@ void WieldMeshSceneNode::setItem(const ItemStack &item, Client *client)
// Color-related
m_colors.clear();
video::SColor basecolor = idef->getItemstackColor(item, client);
m_base_color = idef->getItemstackColor(item, client);
// If wield_image is defined, it overrides everything else
if (def.wield_image != "") {
setExtruded(def.wield_image, def.wield_scale, tsrc, 1);
m_colors.push_back(basecolor);
m_colors.push_back(ItemPartColor());
return;
}
// Handle nodes
@ -334,66 +325,50 @@ void WieldMeshSceneNode::setItem(const ItemStack &item, Client *client)
else if (def.type == ITEM_NODE) {
if (f.mesh_ptr[0]) {
// e.g. mesh nodes and nodeboxes
changeToMesh(f.mesh_ptr[0]);
// mesh_ptr[0] is pre-scaled by BS * f->visual_scale
scene::SMesh *mesh = cloneMesh(f.mesh_ptr[0]);
postProcessNodeMesh(mesh, f, m_enable_shaders, true,
&m_material_type, &m_colors);
changeToMesh(mesh);
mesh->drop();
// mesh is pre-scaled by BS * f->visual_scale
m_meshnode->setScale(
def.wield_scale * WIELD_SCALE_FACTOR
/ (BS * f.visual_scale));
} else if (f.drawtype == NDT_AIRLIKE) {
changeToMesh(NULL);
} else if (f.drawtype == NDT_PLANTLIKE) {
setExtruded(tsrc->getTextureName(f.tiles[0].texture_id), def.wield_scale, tsrc, f.tiles[0].animation_frame_count);
setExtruded(tsrc->getTextureName(f.tiles[0].layers[0].texture_id),
def.wield_scale, tsrc,
f.tiles[0].layers[0].animation_frame_count);
} else if (f.drawtype == NDT_NORMAL || f.drawtype == NDT_ALLFACES) {
setCube(f.tiles, def.wield_scale, tsrc);
setCube(f, def.wield_scale, tsrc);
} else {
MeshMakeData mesh_make_data(client, false);
MapNode mesh_make_node(id, 255, 0);
mesh_make_data.fillSingleNode(&mesh_make_node);
MapBlockMesh mapblock_mesh(&mesh_make_data, v3s16(0, 0, 0));
changeToMesh(mapblock_mesh.getMesh());
translateMesh(m_meshnode->getMesh(), v3f(-BS, -BS, -BS));
scene::SMesh *mesh = cloneMesh(mapblock_mesh.getMesh());
translateMesh(mesh, v3f(-BS, -BS, -BS));
postProcessNodeMesh(mesh, f, m_enable_shaders, true,
&m_material_type, &m_colors);
changeToMesh(mesh);
mesh->drop();
m_meshnode->setScale(
def.wield_scale * WIELD_SCALE_FACTOR
/ (BS * f.visual_scale));
}
u32 material_count = m_meshnode->getMaterialCount();
if (material_count > 6) {
errorstream << "WieldMeshSceneNode::setItem: Invalid material "
"count " << material_count << ", truncating to 6" << std::endl;
material_count = 6;
}
for (u32 i = 0; i < material_count; ++i) {
const TileSpec *tile = &(f.tiles[i]);
video::SMaterial &material = m_meshnode->getMaterial(i);
material.setFlag(video::EMF_BACK_FACE_CULLING, true);
material.setFlag(video::EMF_BILINEAR_FILTER, m_bilinear_filter);
material.setFlag(video::EMF_TRILINEAR_FILTER, m_trilinear_filter);
bool animated = (tile->animation_frame_count > 1);
if (animated) {
FrameSpec animation_frame = tile->frames[0];
material.setTexture(0, animation_frame.texture);
} else {
material.setTexture(0, tile->texture);
}
m_colors.push_back(tile->has_color ? tile->color : basecolor);
material.MaterialType = m_material_type;
if (m_enable_shaders) {
if (tile->normal_texture) {
if (animated) {
FrameSpec animation_frame = tile->frames[0];
material.setTexture(1, animation_frame.normal_texture);
} else {
material.setTexture(1, tile->normal_texture);
}
}
material.setTexture(2, tile->flags_texture);
}
}
return;
}
else if (def.inventory_image != "") {
setExtruded(def.inventory_image, def.wield_scale, tsrc, 1);
m_colors.push_back(basecolor);
m_colors.push_back(ItemPartColor());
return;
}
@ -413,9 +388,9 @@ void WieldMeshSceneNode::setColor(video::SColor c)
u8 blue = c.getBlue();
u32 mc = mesh->getMeshBufferCount();
for (u32 j = 0; j < mc; j++) {
video::SColor bc(0xFFFFFFFF);
if (m_colors.size() > j)
bc = m_colors[j];
video::SColor bc(m_base_color);
if ((m_colors.size() > j) && (m_colors[j].override_base))
bc = m_colors[j].color;
video::SColor buffercolor(255,
bc.getRed() * red / 255,
bc.getGreen() * green / 255,
@ -439,19 +414,7 @@ void WieldMeshSceneNode::changeToMesh(scene::IMesh *mesh)
m_meshnode->setMesh(dummymesh);
dummymesh->drop(); // m_meshnode grabbed it
} else {
if (m_lighting) {
m_meshnode->setMesh(mesh);
} else {
/*
Lighting is disabled, this means the caller can (and probably will)
call setColor later. We therefore need to clone the mesh so that
setColor will only modify this scene node's mesh, not others'.
*/
scene::IMeshManipulator *meshmanip = SceneManager->getMeshManipulator();
scene::IMesh *new_mesh = meshmanip->createMeshCopy(mesh);
m_meshnode->setMesh(new_mesh);
new_mesh->drop(); // m_meshnode grabbed it
}
m_meshnode->setMesh(mesh);
}
m_meshnode->setMaterialFlag(video::EMF_LIGHTING, m_lighting);
@ -475,24 +438,24 @@ void getItemMesh(Client *client, const ItemStack &item, ItemMesh *result)
g_extrusion_mesh_cache->grab();
}
scene::IMesh *mesh;
scene::SMesh *mesh;
// If inventory_image is defined, it overrides everything else
if (def.inventory_image != "") {
mesh = getExtrudedMesh(tsrc, def.inventory_image);
result->mesh = mesh;
result->buffer_colors.push_back(
std::pair<bool, video::SColor>(false, video::SColor(0xFFFFFFFF)));
result->buffer_colors.push_back(ItemPartColor());
} else if (def.type == ITEM_NODE) {
if (f.mesh_ptr[0]) {
mesh = cloneMesh(f.mesh_ptr[0]);
scaleMesh(mesh, v3f(0.12, 0.12, 0.12));
} else if (f.drawtype == NDT_PLANTLIKE) {
mesh = getExtrudedMesh(tsrc,
tsrc->getTextureName(f.tiles[0].texture_id));
tsrc->getTextureName(f.tiles[0].layers[0].texture_id));
} else if (f.drawtype == NDT_NORMAL || f.drawtype == NDT_ALLFACES
|| f.drawtype == NDT_LIQUID || f.drawtype == NDT_FLOWINGLIQUID) {
mesh = cloneMesh(g_extrusion_mesh_cache->createCube());
scene::IMesh *cube = g_extrusion_mesh_cache->createCube();
mesh = cloneMesh(cube);
cube->drop();
scaleMesh(mesh, v3f(1.2, 1.2, 1.2));
} else {
MeshMakeData mesh_make_data(client, false);
@ -519,32 +482,27 @@ void getItemMesh(Client *client, const ItemStack &item, ItemMesh *result)
u32 mc = mesh->getMeshBufferCount();
for (u32 i = 0; i < mc; ++i) {
const TileSpec *tile = &(f.tiles[i]);
scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
result->buffer_colors.push_back(
std::pair<bool, video::SColor>(tile->has_color, tile->color));
colorizeMeshBuffer(buf, &tile->color);
video::SMaterial &material = buf->getMaterial();
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
material.setFlag(video::EMF_BILINEAR_FILTER, false);
material.setFlag(video::EMF_TRILINEAR_FILTER, false);
material.setFlag(video::EMF_BACK_FACE_CULLING, true);
material.setFlag(video::EMF_LIGHTING, false);
if (tile->animation_frame_count > 1) {
FrameSpec animation_frame = tile->frames[0];
material.setTexture(0, animation_frame.texture);
} else {
material.setTexture(0, tile->texture);
}
}
rotateMeshXZby(mesh, -45);
rotateMeshYZby(mesh, -30);
result->mesh = mesh;
postProcessNodeMesh(mesh, f, false, false, NULL,
&result->buffer_colors);
}
result->mesh = mesh;
}
scene::IMesh * getExtrudedMesh(ITextureSource *tsrc,
scene::SMesh * getExtrudedMesh(ITextureSource *tsrc,
const std::string &imagename)
{
video::ITexture *texture = tsrc->getTextureForMesh(imagename);
@ -553,7 +511,9 @@ scene::IMesh * getExtrudedMesh(ITextureSource *tsrc,
}
core::dimension2d<u32> dim = texture->getSize();
scene::IMesh *mesh = cloneMesh(g_extrusion_mesh_cache->create(dim));
scene::IMesh *original = g_extrusion_mesh_cache->create(dim);
scene::SMesh *mesh = cloneMesh(original);
original->drop();
// Customize material
video::SMaterial &material = mesh->getMeshBuffer(0)->getMaterial();
@ -569,3 +529,57 @@ scene::IMesh * getExtrudedMesh(ITextureSource *tsrc,
return mesh;
}
void postProcessNodeMesh(scene::SMesh *mesh, const ContentFeatures &f,
bool use_shaders, bool set_material, video::E_MATERIAL_TYPE *mattype,
std::vector<ItemPartColor> *colors)
{
u32 mc = mesh->getMeshBufferCount();
// Allocate colors for existing buffers
colors->clear();
for (u32 i = 0; i < mc; ++i)
colors->push_back(ItemPartColor());
for (u32 i = 0; i < mc; ++i) {
const TileSpec *tile = &(f.tiles[i]);
scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
for (int layernum = 0; layernum < MAX_TILE_LAYERS; layernum++) {
const TileLayer *layer = &tile->layers[layernum];
if (layer->texture_id == 0)
continue;
if (layernum != 0) {
scene::IMeshBuffer *copy = cloneMeshBuffer(buf);
copy->getMaterial() = buf->getMaterial();
mesh->addMeshBuffer(copy);
copy->drop();
buf = copy;
colors->push_back(
ItemPartColor(layer->has_color, layer->color));
} else {
(*colors)[i] = ItemPartColor(layer->has_color, layer->color);
}
video::SMaterial &material = buf->getMaterial();
if (set_material)
layer->applyMaterialOptions(material);
if (mattype) {
material.MaterialType = *mattype;
}
if (layer->animation_frame_count > 1) {
FrameSpec animation_frame = layer->frames[0];
material.setTexture(0, animation_frame.texture);
} else {
material.setTexture(0, layer->texture);
}
if (use_shaders) {
if (layer->normal_texture) {
if (layer->animation_frame_count > 1) {
FrameSpec animation_frame = layer->frames[0];
material.setTexture(1, animation_frame.normal_texture);
} else
material.setTexture(1, layer->normal_texture);
}
material.setTexture(2, layer->flags_texture);
}
}
}
}

55
src/wieldmesh.h
View File

@ -26,17 +26,41 @@ with this program; if not, write to the Free Software Foundation, Inc.,
struct ItemStack;
class Client;
class ITextureSource;
struct TileSpec;
struct ContentFeatures;
/*!
* Holds color information of an item mesh's buffer.
*/
struct ItemPartColor {
/*!
* If this is false, the global base color of the item
* will be used instead of the specific color of the
* buffer.
*/
bool override_base;
/*!
* The color of the buffer.
*/
video::SColor color;
ItemPartColor():
override_base(false),
color(0)
{}
ItemPartColor(bool override, video::SColor color):
override_base(override),
color(color)
{}
};
struct ItemMesh
{
scene::IMesh *mesh;
/*!
* Stores the color of each mesh buffer.
* If the boolean is true, the color is fixed, else
* palettes can modify it.
*/
std::vector<std::pair<bool, video::SColor> > buffer_colors;
std::vector<ItemPartColor> buffer_colors;
ItemMesh() : mesh(NULL), buffer_colors() {}
};
@ -51,7 +75,8 @@ public:
s32 id = -1, bool lighting = false);
virtual ~WieldMeshSceneNode();
void setCube(const TileSpec tiles[6], v3f wield_scale, ITextureSource *tsrc);
void setCube(const ContentFeatures &f, v3f wield_scale,
ITextureSource *tsrc);
void setExtruded(const std::string &imagename, v3f wield_scale,
ITextureSource *tsrc, u8 num_frames);
void setItem(const ItemStack &item, Client *client);
@ -84,7 +109,12 @@ private:
* Stores the colors of the mesh's mesh buffers.
* This does not include lighting.
*/
std::vector<video::SColor> m_colors;
std::vector<ItemPartColor> m_colors;
/*!
* The base color of this mesh. This is the default
* for all mesh buffers.
*/
video::SColor m_base_color;
// Bounding box culling is disabled for this type of scene node,
// so this variable is just required so we can implement
@ -94,5 +124,16 @@ private:
void getItemMesh(Client *client, const ItemStack &item, ItemMesh *result);
scene::IMesh *getExtrudedMesh(ITextureSource *tsrc, const std::string &imagename);
scene::SMesh *getExtrudedMesh(ITextureSource *tsrc, const std::string &imagename);
/*!
* Applies overlays, textures and optionally materials to the given mesh and
* extracts tile colors for colorization.
* \param mattype overrides the buffer's material type, but can also
* be NULL to leave the original material.
* \param colors returns the colors of the mesh buffers in the mesh.
*/
void postProcessNodeMesh(scene::SMesh *mesh, const ContentFeatures &f,
bool use_shaders, bool set_material, video::E_MATERIAL_TYPE *mattype,
std::vector<ItemPartColor> *colors);
#endif