#include "light.h"
#include "mapblock.h"
#include "map.h"
-#include "main.h" // for g_profiler
#include "profiler.h"
#include "nodedef.h"
-#include "gamedef.h"
#include "mesh.h"
+#include "minimap.h"
#include "content_mapblock.h"
#include "noise.h"
#include "shader.h"
#include "settings.h"
#include "util/directiontables.h"
-
-static void applyFacesShading(video::SColor& color, float factor)
-{
- color.setRed(core::clamp(core::round32(color.getRed()*factor), 0, 255));
- color.setGreen(core::clamp(core::round32(color.getGreen()*factor), 0, 255));
-}
+#include <IMeshManipulator.h>
/*
MeshMakeData
*/
-MeshMakeData::MeshMakeData(IGameDef *gamedef, bool use_shaders):
+MeshMakeData::MeshMakeData(Client *client, bool use_shaders,
+ bool use_tangent_vertices):
m_vmanip(),
m_blockpos(-1337,-1337,-1337),
m_crack_pos_relative(-1337, -1337, -1337),
- m_highlighted_pos_relative(-1337, -1337, -1337),
m_smooth_lighting(false),
m_show_hud(false),
- m_highlight_mesh_color(255, 255, 255, 255),
- m_gamedef(gamedef),
- m_use_shaders(use_shaders)
+ m_client(client),
+ m_use_shaders(use_shaders),
+ m_use_tangent_vertices(use_tangent_vertices)
{}
-void MeshMakeData::fill(MapBlock *block)
+void MeshMakeData::fillBlockDataBegin(const v3s16 &blockpos)
{
- m_blockpos = block->getPos();
+ m_blockpos = blockpos;
v3s16 blockpos_nodes = m_blockpos*MAP_BLOCKSIZE;
- /*
- Copy data
- */
-
- // Allocate this block + neighbors
m_vmanip.clear();
VoxelArea voxel_area(blockpos_nodes - v3s16(1,1,1) * MAP_BLOCKSIZE,
blockpos_nodes + v3s16(1,1,1) * MAP_BLOCKSIZE*2-v3s16(1,1,1));
m_vmanip.addArea(voxel_area);
+}
- {
- //TimeTaker timer("copy central block data");
- // 0ms
+void MeshMakeData::fillBlockData(const v3s16 &block_offset, MapNode *data)
+{
+ v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
+ VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
- // Copy our data
- block->copyTo(m_vmanip);
- }
- {
- //TimeTaker timer("copy neighbor block data");
- // 0ms
+ v3s16 bp = m_blockpos + block_offset;
+ v3s16 blockpos_nodes = bp * MAP_BLOCKSIZE;
+ m_vmanip.copyFrom(data, data_area, v3s16(0,0,0), blockpos_nodes, data_size);
+}
+
+void MeshMakeData::fill(MapBlock *block)
+{
+ fillBlockDataBegin(block->getPos());
- /*
- Copy neighbors. This is lightning fast.
- Copying only the borders would be *very* slow.
- */
+ fillBlockData(v3s16(0,0,0), block->getData());
- // Get map
- Map *map = block->getParent();
+ // Get map for reading neigbhor blocks
+ Map *map = block->getParent();
- for(u16 i=0; i<26; i++)
- {
- const v3s16 &dir = g_26dirs[i];
- v3s16 bp = m_blockpos + dir;
- MapBlock *b = map->getBlockNoCreateNoEx(bp);
- if(b)
- b->copyTo(m_vmanip);
- }
+ for (u16 i=0; i<26; i++) {
+ const v3s16 &dir = g_26dirs[i];
+ v3s16 bp = m_blockpos + dir;
+ MapBlock *b = map->getBlockNoCreateNoEx(bp);
+ if(b)
+ fillBlockData(dir, b->getData());
}
}
m_crack_pos_relative = crack_pos - m_blockpos*MAP_BLOCKSIZE;
}
-void MeshMakeData::setHighlighted(v3s16 highlighted_pos, bool show_hud)
-{
- m_show_hud = show_hud;
- m_highlighted_pos_relative = highlighted_pos - m_blockpos*MAP_BLOCKSIZE;
-}
-
void MeshMakeData::setSmoothLighting(bool smooth_lighting)
{
m_smooth_lighting = smooth_lighting;
v3s16(1,1,1),
};
- INodeDefManager *ndef = data->m_gamedef->ndef();
+ INodeDefManager *ndef = data->m_client->ndef();
u16 ambient_occlusion = 0;
u16 light_count = 0;
for (u32 i = 0; i < 8; i++)
{
- const MapNode &n = data->m_vmanip.getNodeRefUnsafeCheckFlags(p - dirs8[i]);
+ MapNode n = data->m_vmanip.getNodeNoExNoEmerge(p - dirs8[i]);
// if it's CONTENT_IGNORE we can't do any light calculations
if (n.getContent() == CONTENT_IGNORE) {
return getSmoothLightCombined(p, 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)
+void get_sunlight_color(video::SColorf *sunlight, u32 daynight_ratio){
+ f32 rg = daynight_ratio / 1000.0f - 0.04f;
+ f32 b = (0.98f * daynight_ratio) / 1000.0f + 0.078f;
+ sunlight->r = rg;
+ sunlight->g = rg;
+ sunlight->b = b;
+}
+
+void final_color_blend(video::SColor *result,
+ u16 light, u32 daynight_ratio)
{
- s32 rg = (day * daynight_ratio + night * (1000-daynight_ratio)) / 1000;
- s32 b = rg;
+ video::SColorf dayLight;
+ get_sunlight_color(&dayLight, daynight_ratio);
+ final_color_blend(result,
+ encode_light_and_color(light, video::SColor(0xFFFFFFFF), 0), dayLight);
+}
+
+void final_color_blend(video::SColor *result,
+ const video::SColor &data, const video::SColorf &dayLight)
+{
+ static const video::SColorf artificialColor(1.04f, 1.04f, 1.04f);
+
+ video::SColorf c(data);
+ f32 n = 1 - c.a;
- // Moonlight is blue
- b += (day - night) / 13;
- rg -= (day - night) / 23;
+ f32 r = c.r * (c.a * dayLight.r + n * artificialColor.r) * 2.0f;
+ f32 g = c.g * (c.a * dayLight.g + n * artificialColor.g) * 2.0f;
+ f32 b = c.b * (c.a * dayLight.b + n * artificialColor.b) * 2.0f;
// Emphase blue a bit in darker places
// Each entry of this array represents a range of 8 blue levels
1, 4, 6, 6, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
- b += emphase_blue_when_dark[irr::core::clamp(b, 0, 255) / 8];
- b = irr::core::clamp(b, 0, 255);
- // Artificial light is yellow-ish
- static const u8 emphase_yellow_when_artificial[16] = {
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 10, 15, 15, 15
- };
- rg += emphase_yellow_when_artificial[night/16];
- rg = irr::core::clamp(rg, 0, 255);
+ b += emphase_blue_when_dark[irr::core::clamp((s32) ((r + g + b) / 3 * 255),
+ 0, 255) / 8] / 255.0f;
- result.setRed(rg);
- result.setGreen(rg);
- result.setBlue(b);
+ result->setRed(core::clamp((s32) (r * 255.0f), 0, 255));
+ result->setGreen(core::clamp((s32) (g * 255.0f), 0, 255));
+ result->setBlue(core::clamp((s32) (b * 255.0f), 0, 255));
}
/*
};
static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3,
- v3f p, v3s16 dir, v3f scale, u8 light_source, 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;
v3f normal(dir.X, dir.Y, dir.Z);
- u8 alpha = tile.alpha;
-
dest.push_back(FastFace());
FastFace& face = *dest.rbegin();
- face.vertices[0] = video::S3DVertex(vertex_pos[0], normal,
- MapBlock_LightColor(alpha, li0, light_source),
- core::vector2d<f32>(x0+w*abs_scale, y0+h));
- face.vertices[1] = video::S3DVertex(vertex_pos[1], normal,
- MapBlock_LightColor(alpha, li1, light_source),
- core::vector2d<f32>(x0, y0+h));
- face.vertices[2] = video::S3DVertex(vertex_pos[2], normal,
- MapBlock_LightColor(alpha, li2, light_source),
- core::vector2d<f32>(x0, y0));
- face.vertices[3] = video::S3DVertex(vertex_pos[3], normal,
- MapBlock_LightColor(alpha, li3, light_source),
- core::vector2d<f32>(x0+w*abs_scale, y0));
+ u16 li[4] = { li0, li1, li2, li3 };
+ 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);
+
+ face.vertices[i] = video::S3DVertex(vertex_pos[i], normal, c, f[i]);
+ }
face.tile = tile;
}
*/
TileSpec getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data)
{
- INodeDefManager *ndef = data->m_gamedef->ndef();
- TileSpec spec = ndef->get(mn).tiles[tileindex];
+ 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);
// Apply temporary crack
if (p == data->m_crack_pos_relative)
spec.material_flags |= MATERIAL_FLAG_CRACK;
*/
TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data)
{
- INodeDefManager *ndef = data->m_gamedef->ndef();
+ INodeDefManager *ndef = data->m_client->ndef();
// Direction must be (1,0,0), (-1,0,0), (0,1,0), (0,-1,0),
// (0,0,1), (0,0,-1) or (0,0,0)
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_gamedef->tsrc()->getTexture(spec.texture_id);
+ spec.texture = data->m_client->tsrc()->getTexture(spec.texture_id);
return spec;
}
v3s16 &p_corrected,
v3s16 &face_dir_corrected,
u16 *lights,
- TileSpec &tile,
- u8 &light_source
+ TileSpec &tile
)
{
VoxelManipulator &vmanip = data->m_vmanip;
- INodeDefManager *ndef = data->m_gamedef->ndef();
+ INodeDefManager *ndef = data->m_client->ndef();
v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE;
MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p);
return;
}
- const MapNode &n1 = vmanip.getNodeRefUnsafeCheckFlags(blockpos_nodes + p + face_dir);
+ const MapNode &n1 = vmanip.getNodeRefUnsafeCheckFlags(
+ blockpos_nodes + p + face_dir);
if (n1.getContent() == CONTENT_IGNORE) {
makes_face = false;
makes_face = true;
- if(mf == 1)
- {
- tile = getNodeTile(n0, p, face_dir, data);
+ MapNode n = n0;
+
+ if (mf == 1) {
p_corrected = p;
face_dir_corrected = face_dir;
- light_source = ndef->get(n0).light_source;
- }
- else
- {
- tile = getNodeTile(n1, p + face_dir, -face_dir, data);
+ } else {
+ n = n1;
p_corrected = p + face_dir;
face_dir_corrected = -face_dir;
- light_source = ndef->get(n1).light_source;
}
+ tile = getNodeTile(n, p_corrected, face_dir_corrected, data);
+ const ContentFeatures &f = ndef->get(n);
+ tile.emissive_light = f.light_source;
// eg. water and glass
- if(equivalent)
+ if (equivalent)
tile.material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
- if(data->m_smooth_lighting == false)
+ if (data->m_smooth_lighting == false)
{
lights[0] = lights[1] = lights[2] = lights[3] =
getFaceLight(n0, n1, face_dir, ndef);
{
v3s16 p = startpos;
- u16 continuous_tiles_count = 0;
+ u16 continuous_tiles_count = 1;
bool makes_face = false;
v3s16 p_corrected;
v3s16 face_dir_corrected;
u16 lights[4] = {0,0,0,0};
TileSpec tile;
- u8 light_source = 0;
getTileInfo(data, p, face_dir,
makes_face, p_corrected, face_dir_corrected,
- lights, tile, light_source);
+ lights, tile);
- for(u16 j=0; j<MAP_BLOCKSIZE; j++)
- {
+ // Unroll this variable which has a significant build cost
+ TileSpec next_tile;
+ for (u16 j = 0; j < MAP_BLOCKSIZE; j++) {
// If tiling can be done, this is set to false in the next step
bool next_is_different = true;
v3s16 next_p_corrected;
v3s16 next_face_dir_corrected;
u16 next_lights[4] = {0,0,0,0};
- TileSpec next_tile;
- u8 next_light_source = 0;
+
// If at last position, there is nothing to compare to and
// the face must be drawn anyway
- if(j != MAP_BLOCKSIZE - 1)
- {
+ if (j != MAP_BLOCKSIZE - 1) {
p_next = p + translate_dir;
getTileInfo(data, p_next, face_dir,
next_makes_face, next_p_corrected,
next_face_dir_corrected, next_lights,
- next_tile, next_light_source);
+ next_tile);
- if(next_makes_face == makes_face
+ if (next_makes_face == makes_face
&& next_p_corrected == p_corrected + translate_dir
&& next_face_dir_corrected == face_dir_corrected
&& next_lights[0] == lights[0]
&& next_lights[3] == lights[3]
&& next_tile == tile
&& tile.rotation == 0
- && next_light_source == light_source)
- {
+ && (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_is_different = false;
+ continuous_tiles_count++;
}
- else{
- /*if(makes_face){
- g_profiler->add("Meshgen: diff: next_makes_face != makes_face",
- next_makes_face != makes_face ? 1 : 0);
- g_profiler->add("Meshgen: diff: n_p_corr != p_corr + t_dir",
- (next_p_corrected != p_corrected + translate_dir) ? 1 : 0);
- g_profiler->add("Meshgen: diff: next_f_dir_corr != f_dir_corr",
- next_face_dir_corrected != face_dir_corrected ? 1 : 0);
- g_profiler->add("Meshgen: diff: next_lights[] != lights[]",
- (next_lights[0] != lights[0] ||
- next_lights[0] != lights[0] ||
- next_lights[0] != lights[0] ||
- next_lights[0] != lights[0]) ? 1 : 0);
- g_profiler->add("Meshgen: diff: !(next_tile == tile)",
- !(next_tile == tile) ? 1 : 0);
- }*/
- }
- /*g_profiler->add("Meshgen: Total faces checked", 1);
- if(makes_face)
- g_profiler->add("Meshgen: Total makes_face checked", 1);*/
- } else {
- /*if(makes_face)
- g_profiler->add("Meshgen: diff: last position", 1);*/
}
- continuous_tiles_count++;
-
- if(next_is_different)
- {
+ if (next_is_different) {
/*
Create a face if there should be one
*/
- if(makes_face)
- {
+ if (makes_face) {
// Floating point conversion of the position vector
v3f pf(p_corrected.X, p_corrected.Y, p_corrected.Z);
// Center point of face (kind of)
v3f sp = pf - ((f32)continuous_tiles_count / 2.0 - 0.5) * translate_dir_f;
- if(continuous_tiles_count != 1)
- sp += translate_dir_f;
v3f scale(1,1,1);
if(translate_dir.X != 0) {
}
makeFastFace(tile, lights[0], lights[1], lights[2], lights[3],
- sp, face_dir_corrected, scale, light_source,
- dest);
+ sp, face_dir_corrected, scale, dest);
g_profiler->avg("Meshgen: faces drawn by tiling", 0);
for(int i = 1; i < continuous_tiles_count; i++){
}
}
- continuous_tiles_count = 0;
-
- makes_face = next_makes_face;
- p_corrected = next_p_corrected;
- face_dir_corrected = next_face_dir_corrected;
- lights[0] = next_lights[0];
- lights[1] = next_lights[1];
- lights[2] = next_lights[2];
- lights[3] = next_lights[3];
- tile = next_tile;
- light_source = next_light_source;
+ continuous_tiles_count = 1;
}
+ makes_face = next_makes_face;
+ p_corrected = next_p_corrected;
+ face_dir_corrected = next_face_dir_corrected;
+ std::memcpy(lights, next_lights, ARRLEN(lights) * sizeof(u16));
+ if (next_is_different)
+ tile = next_tile;
p = p_next;
}
}
MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset):
m_mesh(new scene::SMesh()),
- m_gamedef(data->m_gamedef),
+ m_minimap_mapblock(NULL),
+ m_client(data->m_client),
+ m_driver(m_client->tsrc()->getDevice()->getVideoDriver()),
+ m_tsrc(m_client->getTextureSource()),
+ m_shdrsrc(m_client->getShaderSource()),
m_animation_force_timer(0), // force initial animation
m_last_crack(-1),
m_crack_materials(),
- m_highlighted_materials(),
m_last_daynight_ratio((u32) -1),
m_daynight_diffs()
{
m_enable_shaders = data->m_use_shaders;
- m_enable_highlighting = g_settings->getBool("enable_node_highlighting");
+ m_use_tangent_vertices = data->m_use_tangent_vertices;
+ m_enable_vbo = g_settings->getBool("enable_vbo");
+
+ if (g_settings->getBool("enable_minimap")) {
+ m_minimap_mapblock = new MinimapMapblock;
+ m_minimap_mapblock->getMinimapNodes(
+ &data->m_vmanip, data->m_blockpos * MAP_BLOCKSIZE);
+ }
// 4-21ms for MAP_BLOCKSIZE=16 (NOTE: probably outdated)
// 24-155ms for MAP_BLOCKSIZE=32 (NOTE: probably outdated)
Convert FastFaces to MeshCollector
*/
- MeshCollector collector;
+ MeshCollector collector(m_use_tangent_vertices);
{
// avg 0ms (100ms spikes when loading textures the first time)
// (NOTE: probably outdated)
//TimeTaker timer2("MeshCollector building");
- for(u32 i=0; i<fastfaces_new.size(); i++)
- {
+ for (u32 i = 0; i < fastfaces_new.size(); i++) {
FastFace &f = fastfaces_new[i];
const u16 indices[] = {0,1,2,2,3,0};
const u16 *indices_p = indices;
/*
- Revert triangles for nicer looking gradient if vertices
- 1 and 3 have same color or 0 and 2 have different color.
- getRed() is the day color.
+ 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(f.vertices[0].Color.getRed() != f.vertices[2].Color.getRed()
- || f.vertices[1].Color.getRed() == f.vertices[3].Color.getRed())
+ 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);
- whatever
*/
- mapblock_mesh_generate_special(data, collector);
-
- m_highlight_mesh_color = data->m_highlight_mesh_color;
+ {
+ MapblockMeshGenerator generator(data, &collector);
+ generator.generate();
+ }
/*
Convert MeshCollector to SMesh
*/
- ITextureSource *tsrc = m_gamedef->tsrc();
- IShaderSource *shdrsrc = m_gamedef->getShaderSource();
for(u32 i = 0; i < collector.prebuffers.size(); i++)
{
{
// Find the texture name plus ^[crack:N:
std::ostringstream os(std::ios::binary);
- os<<tsrc->getTextureName(p.tile.texture_id)<<"^[crack";
+ 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 = tsrc->getTexture(
+ p.tile.texture = m_tsrc->getTextureForMesh(
os.str()+"0",
&p.tile.texture_id);
}
// - Texture animation
- if(p.tile.material_flags & MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
- {
+ 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;
p.tile.texture = animation_frame.texture;
}
- if(m_enable_highlighting && p.tile.material_flags & MATERIAL_FLAG_HIGHLIGHTED)
- m_highlighted_materials.push_back(i);
-
- for(u32 j = 0; j < p.vertices.size(); j++)
- {
- // Note applyFacesShading second parameter is precalculated sqrt
- // value for speed improvement
- // Skip it for lightsources and top faces.
- video::SColor &vc = p.vertices[j].Color;
- if (!vc.getBlue()) {
- if (p.vertices[j].Normal.Y < -0.5) {
- applyFacesShading (vc, 0.447213);
- } else if (p.vertices[j].Normal.X > 0.5) {
- applyFacesShading (vc, 0.670820);
- } else if (p.vertices[j].Normal.X < -0.5) {
- applyFacesShading (vc, 0.670820);
- } else if (p.vertices[j].Normal.Z > 0.5) {
- applyFacesShading (vc, 0.836660);
- } else if (p.vertices[j].Normal.Z < -0.5) {
- applyFacesShading (vc, 0.836660);
+ 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;
}
- }
- if(!m_enable_shaders)
- {
- // - Classic lighting (shaders handle this by themselves)
- // Set initial real color and store for later updates
- u8 day = vc.getRed();
- u8 night = vc.getGreen();
- finalColorBlend(vc, day, night, 1000);
- if(day != night)
- m_daynight_diffs[i][j] = std::make_pair(day, night);
+ 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;
+
+ // The sunlight ratio has been stored,
+ // delete alpha (for the final rendering).
+ vc->setAlpha(255);
}
}
material.setFlag(video::EMF_FOG_ENABLE, true);
material.setTexture(0, p.tile.texture);
- if (p.tile.material_flags & MATERIAL_FLAG_HIGHLIGHTED) {
- material.MaterialType = video::EMT_TRANSPARENT_ADD_COLOR;
- } else {
- if (m_enable_shaders) {
- material.MaterialType = 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, tsrc->getTexture("enable_img.png"));
- } else {
- material.setTexture(2, tsrc->getTexture("disable_img.png"));
- }
- } else {
- p.tile.applyMaterialOptions(material);
+ 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);
}
- // Create meshbuffer
- // This is a "Standard MeshBuffer",
- // it's a typedeffed CMeshBuffer<video::S3DVertex>
- scene::SMeshBuffer *buf = new scene::SMeshBuffer();
- // Set material
- buf->Material = material;
- // Add to mesh
- m_mesh->addMeshBuffer(buf);
- // Mesh grabbed it
- buf->drop();
- buf->append(&p.vertices[0], p.vertices.size(),
+ 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());
+ }
}
- m_camera_offset = camera_offset;
-
/*
Do some stuff to the mesh
*/
+ m_camera_offset = camera_offset;
+ translateMesh(m_mesh,
+ intToFloat(data->m_blockpos * MAP_BLOCKSIZE - camera_offset, BS));
- 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)
{
#if 0
// Usually 1-700 faces and 1-7 materials
#endif
// Use VBO for mesh (this just would set this for ever buffer)
- // This will lead to infinite memory usage because or irrlicht.
- //m_mesh->setHardwareMappingHint(scene::EHM_STATIC);
-
- /*
- NOTE: If that is enabled, some kind of a queue to the main
- thread should be made which would call irrlicht to delete
- the hardware buffer and then delete the mesh
- */
+ if (m_enable_vbo) {
+ m_mesh->setHardwareMappingHint(scene::EHM_STATIC);
+ }
}
//std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
m_has_animation =
!m_crack_materials.empty() ||
!m_daynight_diffs.empty() ||
- !m_animation_tiles.empty() ||
- !m_highlighted_materials.empty();
+ !m_animation_tiles.empty();
}
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);
+ }
+ }
m_mesh->drop();
m_mesh = NULL;
+ delete m_minimap_mapblock;
}
bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_ratio)
{
-
if(!m_has_animation)
{
m_animation_force_timer = 100000;
// Cracks
if(crack != m_last_crack)
{
- for(std::map<u32, std::string>::iterator
- i = m_crack_materials.begin();
- i != m_crack_materials.end(); i++)
- {
+ 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);
std::string basename = i->second;
// Create new texture name from original
- ITextureSource *tsrc = m_gamedef->getTextureSource();
std::ostringstream os;
os<<basename<<crack;
u32 new_texture_id = 0;
video::ITexture *new_texture =
- tsrc->getTexture(os.str(), &new_texture_id);
+ m_tsrc->getTextureForMesh(os.str(), &new_texture_id);
buf->getMaterial().setTexture(0, new_texture);
// If the current material is also animated,
// update animation info
- std::map<u32, TileSpec>::iterator anim_iter =
- m_animation_tiles.find(i->first);
- if(anim_iter != m_animation_tiles.end()){
+ UNORDERED_MAP<u32, TileSpec>::iterator anim_iter =
+ m_animation_tiles.find(i->first);
+ if (anim_iter != m_animation_tiles.end()){
TileSpec &tile = anim_iter->second;
tile.texture = new_texture;
tile.texture_id = new_texture_id;
}
// Texture animation
- for(std::map<u32, TileSpec>::iterator
- i = m_animation_tiles.begin();
- i != m_animation_tiles.end(); i++)
- {
+ for (UNORDERED_MAP<u32, TileSpec>::iterator i = m_animation_tiles.begin();
+ i != m_animation_tiles.end(); ++i) {
const TileSpec &tile = i->second;
// Figure out current frame
int frameoffset = m_animation_frame_offsets[i->first];
m_animation_frames[i->first] = frame;
scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first);
- ITextureSource *tsrc = m_gamedef->getTextureSource();
FrameSpec animation_frame = tile.frames[frame];
buf->getMaterial().setTexture(0, animation_frame.texture);
if (m_enable_shaders) {
if (animation_frame.normal_texture) {
buf->getMaterial().setTexture(1, animation_frame.normal_texture);
- buf->getMaterial().setTexture(2, tsrc->getTexture("enable_img.png"));
- } else {
- buf->getMaterial().setTexture(2, tsrc->getTexture("disable_img.png"));
}
+ buf->getMaterial().setTexture(2, animation_frame.flags_texture);
}
}
// Day-night transition
if(!m_enable_shaders && (daynight_ratio != m_last_daynight_ratio))
{
- for(std::map<u32, std::map<u32, std::pair<u8, u8> > >::iterator
+ // Force reload mesh to VBO
+ if (m_enable_vbo) {
+ m_mesh->setDirty();
+ }
+ video::SColorf day_color;
+ get_sunlight_color(&day_color, daynight_ratio);
+ for(std::map<u32, std::map<u32, video::SColor > >::iterator
i = m_daynight_diffs.begin();
- i != m_daynight_diffs.end(); i++)
+ i != m_daynight_diffs.end(); ++i)
{
scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first);
- video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
- for(std::map<u32, std::pair<u8, u8 > >::iterator
+ video::S3DVertex *vertices = (video::S3DVertex *)buf->getVertices();
+ for(std::map<u32, video::SColor >::iterator
j = i->second.begin();
- j != i->second.end(); j++)
+ j != i->second.end(); ++j)
{
- u32 vertexIndex = j->first;
- u8 day = j->second.first;
- u8 night = j->second.second;
- finalColorBlend(vertices[vertexIndex].Color,
- day, night, daynight_ratio);
+ final_color_blend(&(vertices[j->first].Color), j->second, day_color);
}
}
m_last_daynight_ratio = daynight_ratio;
}
- // Node highlighting
- if (m_enable_highlighting) {
- u8 day = m_highlight_mesh_color.getRed();
- u8 night = m_highlight_mesh_color.getGreen();
- video::SColor hc;
- finalColorBlend(hc, day, night, daynight_ratio);
- float sin_r = 0.07 * sin(1.5 * time);
- float sin_g = 0.07 * sin(1.5 * time + irr::core::PI * 0.5);
- float sin_b = 0.07 * sin(1.5 * time + irr::core::PI);
- hc.setRed(core::clamp(core::round32(hc.getRed() * (0.8 + sin_r)), 0, 255));
- hc.setGreen(core::clamp(core::round32(hc.getGreen() * (0.8 + sin_g)), 0, 255));
- hc.setBlue(core::clamp(core::round32(hc.getBlue() * (0.8 + sin_b)), 0, 255));
-
- for(std::list<u32>::iterator
- i = m_highlighted_materials.begin();
- i != m_highlighted_materials.end(); i++)
- {
- scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(*i);
- video::S3DVertex *vertices = (video::S3DVertex*)buf->getVertices();
- for (u32 j = 0; j < buf->getVertexCount() ;j++)
- vertices[j].Color = hc;
- }
- }
-
return true;
}
{
if (camera_offset != m_camera_offset) {
translateMesh(m_mesh, intToFloat(m_camera_offset-camera_offset, BS));
+ if (m_enable_vbo) {
+ m_mesh->setDirty();
+ }
m_camera_offset = camera_offset;
}
}
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices)
{
- if(numIndices > 65535)
- {
+ if (numIndices > 65535) {
dstream<<"FIXME: MeshCollector::append() called with numIndices="<<numIndices<<" (limit 65535)"<<std::endl;
return;
}
PreMeshBuffer *p = NULL;
- for(u32 i=0; i<prebuffers.size(); i++)
- {
+ for (u32 i = 0; i < prebuffers.size(); i++) {
PreMeshBuffer &pp = prebuffers[i];
- if(pp.tile != tile)
+ if (pp.tile != tile)
continue;
- if(pp.indices.size() + numIndices > 65535)
+ if (pp.indices.size() + numIndices > 65535)
continue;
p = &pp;
break;
}
- if(p == NULL)
- {
+ if (p == NULL) {
PreMeshBuffer pp;
pp.tile = tile;
prebuffers.push_back(pp);
- p = &prebuffers[prebuffers.size()-1];
+ p = &prebuffers[prebuffers.size() - 1];
}
- u32 vertex_count = p->vertices.size();
- for(u32 i=0; i<numIndices; i++)
- {
+ u32 vertex_count;
+ if (m_use_tangent_vertices) {
+ vertex_count = p->tangent_vertices.size();
+ for (u32 i = 0; i < numVertices; i++) {
+ video::S3DVertexTangents vert(vertices[i].Pos, vertices[i].Normal,
+ vertices[i].Color, vertices[i].TCoords);
+ p->tangent_vertices.push_back(vert);
+ }
+ } else {
+ vertex_count = p->vertices.size();
+ for (u32 i = 0; i < numVertices; i++) {
+ video::S3DVertex vert(vertices[i].Pos, vertices[i].Normal,
+ vertices[i].Color, vertices[i].TCoords);
+ p->vertices.push_back(vert);
+ }
+ }
+
+ for (u32 i = 0; i < numIndices; i++) {
u32 j = indices[i] + vertex_count;
p->indices.push_back(j);
}
- for(u32 i=0; i<numVertices; i++)
- {
- p->vertices.push_back(vertices[i]);
- }
}
/*
void MeshCollector::append(const TileSpec &tile,
const video::S3DVertex *vertices, u32 numVertices,
const u16 *indices, u32 numIndices,
- v3f pos, video::SColor c)
+ v3f pos, video::SColor c, u8 light_source)
{
- if(numIndices > 65535)
- {
+ if (numIndices > 65535) {
dstream<<"FIXME: MeshCollector::append() called with numIndices="<<numIndices<<" (limit 65535)"<<std::endl;
return;
}
PreMeshBuffer *p = NULL;
- for(u32 i=0; i<prebuffers.size(); i++)
- {
+ for (u32 i = 0; i < prebuffers.size(); i++) {
PreMeshBuffer &pp = prebuffers[i];
if(pp.tile != tile)
continue;
break;
}
- if(p == NULL)
- {
+ if (p == NULL) {
PreMeshBuffer pp;
pp.tile = tile;
prebuffers.push_back(pp);
- p = &prebuffers[prebuffers.size()-1];
+ p = &prebuffers[prebuffers.size() - 1];
}
- u32 vertex_count = p->vertices.size();
- for(u32 i=0; i<numIndices; i++)
- {
+ video::SColor original_c = c;
+ u32 vertex_count;
+ if (m_use_tangent_vertices) {
+ vertex_count = p->tangent_vertices.size();
+ for (u32 i = 0; i < numVertices; i++) {
+ if (!light_source) {
+ c = original_c;
+ applyFacesShading(c, vertices[i].Normal);
+ }
+ video::S3DVertexTangents vert(vertices[i].Pos + pos,
+ vertices[i].Normal, c, vertices[i].TCoords);
+ p->tangent_vertices.push_back(vert);
+ }
+ } else {
+ vertex_count = p->vertices.size();
+ for (u32 i = 0; i < numVertices; i++) {
+ if (!light_source) {
+ c = original_c;
+ applyFacesShading(c, vertices[i].Normal);
+ }
+ video::S3DVertex vert(vertices[i].Pos + pos, vertices[i].Normal, c,
+ vertices[i].TCoords);
+ p->vertices.push_back(vert);
+ }
+ }
+
+ for (u32 i = 0; i < numIndices; i++) {
u32 j = indices[i] + vertex_count;
p->indices.push_back(j);
}
- for(u32 i=0; i<numVertices; i++)
- {
- video::S3DVertex vert = vertices[i];
- vert.Pos += pos;
- vert.Color = c;
- p->vertices.push_back(vert);
- }
+}
+
+video::SColor encode_light_and_color(u16 light, const video::SColor &color,
+ u8 emissive_light)
+{
+ // Get components
+ f32 day = (light & 0xff) / 255.0f;
+ f32 night = (light >> 8) / 255.0f;
+ // Add emissive light
+ night += emissive_light * 0.01f;
+ if (night > 255)
+ night = 255;
+ // Since we don't know if the day light is sunlight or
+ // artificial light, assume it is artificial when the night
+ // light bank is also lit.
+ if (day < night)
+ day = 0;
+ else
+ day = day - night;
+ f32 sum = day + night;
+ // Ratio of sunlight:
+ float r;
+ if (sum > 0)
+ r = day / 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());
}
projects / minetest.git / blobdiff