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)
{}
// Allocate this block + neighbors
m_vmanip.clear();
- m_vmanip.addArea(VoxelArea(blockpos_nodes-v3s16(1,1,1)*MAP_BLOCKSIZE,
- blockpos_nodes+v3s16(1,1,1)*MAP_BLOCKSIZE*2-v3s16(1,1,1)));
+ 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");
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;
/*
Calculate smooth lighting at the XYZ- corner of p.
- Single light bank.
+ Both light banks
*/
-static u8 getSmoothLight(enum LightBank bank, v3s16 p, MeshMakeData *data)
+static u16 getSmoothLightCombined(v3s16 p, MeshMakeData *data)
{
- static v3s16 dirs8[8] = {
+ static const v3s16 dirs8[8] = {
v3s16(0,0,0),
v3s16(0,0,1),
v3s16(0,1,0),
INodeDefManager *ndef = data->m_gamedef->ndef();
u16 ambient_occlusion = 0;
- u16 light = 0;
u16 light_count = 0;
u8 light_source_max = 0;
- for(u32 i=0; i<8; i++)
+ u16 light_day = 0;
+ u16 light_night = 0;
+
+ for (u32 i = 0; i < 8; i++)
{
MapNode n = data->m_vmanip.getNodeNoEx(p - dirs8[i]);
}
const ContentFeatures &f = ndef->get(n);
- if(f.light_source > light_source_max)
+ if (f.light_source > light_source_max)
light_source_max = f.light_source;
- // Check f.solidness because fast-style leaves look
- // better this way
- if(f.param_type == CPT_LIGHT && f.solidness != 2)
- {
- light += decode_light(n.getLight(bank, ndef));
+ // Check f.solidness because fast-style leaves look better this way
+ if (f.param_type == CPT_LIGHT && f.solidness != 2) {
+ light_day += decode_light(n.getLightNoChecks(LIGHTBANK_DAY, &f));
+ light_night += decode_light(n.getLightNoChecks(LIGHTBANK_NIGHT, &f));
light_count++;
- }
- else {
+ } else {
ambient_occlusion++;
}
}
if(light_count == 0)
- return 255;
+ return 0xffff;
- light /= light_count;
+ light_day /= light_count;
+ light_night /= light_count;
// Boost brightness around light sources
- if(decode_light(light_source_max) >= light)
- //return decode_light(undiminish_light(light_source_max));
- return decode_light(light_source_max);
+ bool skip_ambient_occlusion_day = false;
+ if(decode_light(light_source_max) >= light_day) {
+ light_day = decode_light(light_source_max);
+ skip_ambient_occlusion_day = true;
+ }
+
+ bool skip_ambient_occlusion_night = false;
+ if(decode_light(light_source_max) >= light_night) {
+ light_night = decode_light(light_source_max);
+ skip_ambient_occlusion_night = true;
+ }
- if(ambient_occlusion > 4)
+ if (ambient_occlusion > 4)
{
+ static const float ao_gamma = rangelim(
+ g_settings->getFloat("ambient_occlusion_gamma"), 0.25, 4.0);
+
+ // Table of gamma space multiply factors.
+ static const float light_amount[3] = {
+ powf(0.75, 1.0 / ao_gamma),
+ powf(0.5, 1.0 / ao_gamma),
+ powf(0.25, 1.0 / ao_gamma)
+ };
+
//calculate table index for gamma space multiplier
ambient_occlusion -= 5;
- //table of precalculated gamma space multiply factors
- //light^2.2 * factor (0.75, 0.5, 0.25, 0.0), so table holds factor ^ (1 / 2.2)
- const float light_amount[4] = {0.877424315, 0.729740053, 0.532520545, 0.0};
- light = core::clamp(core::round32(light*light_amount[ambient_occlusion]), 0, 255);
+
+ if (!skip_ambient_occlusion_day)
+ light_day = rangelim(core::round32(light_day*light_amount[ambient_occlusion]), 0, 255);
+ if (!skip_ambient_occlusion_night)
+ light_night = rangelim(core::round32(light_night*light_amount[ambient_occlusion]), 0, 255);
}
- return light;
-}
-
-/*
- Calculate smooth lighting at the XYZ- corner of p.
- Both light banks.
-*/
-static u16 getSmoothLight(v3s16 p, MeshMakeData *data)
-{
- u16 day = getSmoothLight(LIGHTBANK_DAY, p, data);
- u16 night = getSmoothLight(LIGHTBANK_NIGHT, p, data);
- return day | (night << 8);
+ return light_day | (light_night << 8);
}
/*
u16 getSmoothLight(v3s16 p, v3s16 corner, MeshMakeData *data)
{
if(corner.X == 1) p.X += 1;
- else assert(corner.X == -1);
+ // else corner.X == -1
if(corner.Y == 1) p.Y += 1;
- else assert(corner.Y == -1);
+ // else corner.Y == -1
if(corner.Z == 1) p.Z += 1;
- else assert(corner.Z == -1);
+ // else corner.Z == -1
- return getSmoothLight(p, data);
+ return getSmoothLightCombined(p, data);
}
/*
Converts from day + night color values (0..255)
and a given daynight_ratio to the final SColor shown on screen.
*/
-static void finalColorBlend(video::SColor& result,
+void finalColorBlend(video::SColor& result,
u8 day, u8 night, u32 daynight_ratio)
{
s32 rg = (day * daynight_ratio + night * (1000-daynight_ratio)) / 1000;
// Emphase blue a bit in darker places
// Each entry of this array represents a range of 8 blue levels
- static u8 emphase_blue_when_dark[32] = {
+ static const u8 emphase_blue_when_dark[32] = {
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[b / 8];
- b = irr::core::clamp (b, 0, 255);
+ 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 u8 emphase_yellow_when_artificial[16] = {
+ 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);
+ rg = irr::core::clamp(rg, 0, 255);
result.setRed(rg);
result.setGreen(rg);
INodeDefManager *ndef = data->m_gamedef->ndef();
TileSpec spec = ndef->get(mn).tiles[tileindex];
// Apply temporary crack
- if(p == data->m_crack_pos_relative)
- {
+ if (p == data->m_crack_pos_relative)
spec.material_flags |= MATERIAL_FLAG_CRACK;
- }
return spec;
}
// Get rotation for things like chests
u8 facedir = mn.getFaceDir(ndef);
- if (facedir > 23)
- facedir = 0;
+
static const u16 dir_to_tile[24 * 16] =
{
// 0 +X +Y +Z -Z -Y -X -> value=tile,rotation
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 = g_settings->getBool("enable_shaders");
+ m_enable_highlighting = g_settings->getBool("enable_node_highlighting");
+
// 4-21ms for MAP_BLOCKSIZE=16 (NOTE: probably outdated)
// 24-155ms for MAP_BLOCKSIZE=32 (NOTE: probably outdated)
//TimeTaker timer1("MapBlockMesh()");
mapblock_mesh_generate_special(data, collector);
+ m_highlight_mesh_color = data->m_highlight_mesh_color;
/*
Convert MeshCollector to SMesh
ITextureSource *tsrc = m_gamedef->tsrc();
IShaderSource *shdrsrc = m_gamedef->getShaderSource();
- bool enable_shaders = g_settings->getBool("enable_shaders");
-
for(u32 i = 0; i < collector.prebuffers.size(); i++)
{
PreMeshBuffer &p = collector.prebuffers[i];
- /*dstream<<"p.vertices.size()="<<p.vertices.size()
- <<", p.indices.size()="<<p.indices.size()
- <<std::endl;*/
// Generate animation data
// - Cracks
m_animation_frame_offsets[i] = 0;
}
// Replace tile texture with the first animation frame
- FrameSpec animation_frame = p.tile.frames.find(0)->second;
+ FrameSpec animation_frame = p.tile.frames[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
applyFacesShading (vc, 0.836660);
}
}
- // - Classic lighting
- // 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);
+ 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);
+ }
}
// Create material
material.setFlag(video::EMF_BACK_FACE_CULLING, true);
material.setFlag(video::EMF_BILINEAR_FILTER, false);
material.setFlag(video::EMF_FOG_ENABLE, true);
- //material.setFlag(video::EMF_ANTI_ALIASING, video::EAAM_OFF);
- //material.setFlag(video::EMF_ANTI_ALIASING, video::EAAM_SIMPLE);
- //material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
material.setTexture(0, p.tile.texture);
- if (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"));
+ 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 {
- material.setTexture(2, tsrc->getTexture("disable_img.png"));
+ p.tile.applyMaterialOptions(material);
}
- } else {
- p.tile.applyMaterialOptions(material);
}
// Create meshbuffer
m_has_animation =
!m_crack_materials.empty() ||
!m_daynight_diffs.empty() ||
- !m_animation_tiles.empty();
+ !m_animation_tiles.empty() ||
+ !m_highlighted_materials.empty();
}
MapBlockMesh::~MapBlockMesh()
bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_ratio)
{
- bool enable_shaders = g_settings->getBool("enable_shaders");
if(!m_has_animation)
{
scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(i->first);
ITextureSource *tsrc = m_gamedef->getTextureSource();
- FrameSpec animation_frame = tile.frames.find(frame)->second;
+ FrameSpec animation_frame = tile.frames[frame];
buf->getMaterial().setTexture(0, animation_frame.texture);
- if (enable_shaders) {
+ 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"));
}
// Day-night transition
- if(daynight_ratio != m_last_daynight_ratio)
+ if(!m_enable_shaders && (daynight_ratio != m_last_daynight_ratio))
{
for(std::map<u32, std::map<u32, std::pair<u8, u8> > >::iterator
i = m_daynight_diffs.begin();
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;
}
p->vertices.push_back(vertices[i]);
}
}
+
+/*
+ MeshCollector - for meshnodes and converted drawtypes.
+*/
+
+void MeshCollector::append(const TileSpec &tile,
+ const video::S3DVertex *vertices, u32 numVertices,
+ const u16 *indices, u32 numIndices,
+ v3f pos, video::SColor c)
+{
+ 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++)
+ {
+ PreMeshBuffer &pp = prebuffers[i];
+ if(pp.tile != tile)
+ continue;
+ if(pp.indices.size() + numIndices > 65535)
+ continue;
+
+ p = &pp;
+ break;
+ }
+
+ if(p == NULL)
+ {
+ PreMeshBuffer pp;
+ pp.tile = tile;
+ prebuffers.push_back(pp);
+ p = &prebuffers[prebuffers.size()-1];
+ }
+
+ u32 vertex_count = p->vertices.size();
+ 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);
+ }
+}
projects / minetest.git / blobdiff