X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fmapblock_mesh.cpp;h=6ae9dec14bf040c934887910e7b6a21cba2c061a;hb=87291ea44a61614d5bd9efc0657926da3f867b5f;hp=d3f7c2f3913f8ec513bf4b900dbb07cd2e44071e;hpb=d9df592da824629149bf744726beba33f604dc2d;p=oweals%2Fminetest.git diff --git a/src/mapblock_mesh.cpp b/src/mapblock_mesh.cpp index d3f7c2f39..6ae9dec14 100644 --- a/src/mapblock_mesh.cpp +++ b/src/mapblock_mesh.cpp @@ -21,16 +21,17 @@ with this program; if not, write to the Free Software Foundation, Inc., #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" +#include static void applyFacesShading(video::SColor& color, float factor) { @@ -42,12 +43,16 @@ static void applyFacesShading(video::SColor& color, float factor) MeshMakeData */ -MeshMakeData::MeshMakeData(IGameDef *gamedef): +MeshMakeData::MeshMakeData(IGameDef *gamedef, bool use_shaders): 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_gamedef(gamedef) + m_show_hud(false), + m_highlight_mesh_color(255, 255, 255, 255), + m_gamedef(gamedef), + m_use_shaders(use_shaders) {} void MeshMakeData::fill(MapBlock *block) @@ -62,8 +67,9 @@ void MeshMakeData::fill(MapBlock *block) // 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"); @@ -132,6 +138,12 @@ void MeshMakeData::setCrack(int crack_level, v3s16 crack_pos) 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; @@ -212,11 +224,11 @@ u16 getFaceLight(MapNode n, MapNode n2, v3s16 face_dir, INodeDefManager *ndef) /* 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), @@ -230,12 +242,14 @@ static u8 getSmoothLight(enum LightBank bank, v3s16 p, MeshMakeData *data) 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 MapNode &n = data->m_vmanip.getNodeRefUnsafeCheckFlags(p - dirs8[i]); // if it's CONTENT_IGNORE we can't do any light calculations if (n.getContent() == CONTENT_IGNORE) { @@ -243,52 +257,59 @@ static u8 getSmoothLight(enum LightBank bank, v3s16 p, MeshMakeData *data) } 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; + } - if(ambient_occlusion > 4) + 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) { + 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); - } - return light; -} + 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); + } -/* - 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); } /* @@ -298,20 +319,20 @@ static u16 getSmoothLight(v3s16 p, MeshMakeData *data) 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; @@ -323,19 +344,19 @@ static void finalColorBlend(video::SColor& result, // 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); @@ -418,8 +439,6 @@ struct FastFace static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3, v3f p, v3s16 dir, v3f scale, u8 light_source, std::vector &dest) { - FastFace face; - // Position is at the center of the cube. v3f pos = p * BS; @@ -570,6 +589,10 @@ static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3, 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(x0+w*abs_scale, y0+h)); @@ -584,7 +607,6 @@ static void makeFastFace(TileSpec tile, u16 li0, u16 li1, u16 li2, u16 li3, core::vector2d(x0+w*abs_scale, y0)); face.tile = tile; - dest.push_back(face); } /* @@ -651,10 +673,8 @@ TileSpec getNodeTileN(MapNode mn, v3s16 p, u8 tileindex, MeshMakeData *data) 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; } @@ -682,8 +702,7 @@ TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data) // 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 @@ -728,8 +747,8 @@ TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 dir, MeshMakeData *data) static void getTileInfo( // Input: MeshMakeData *data, - v3s16 p, - v3s16 face_dir, + const v3s16 &p, + const v3s16 &face_dir, // Output: bool &makes_face, v3s16 &p_corrected, @@ -743,14 +762,20 @@ static void getTileInfo( INodeDefManager *ndef = data->m_gamedef->ndef(); v3s16 blockpos_nodes = data->m_blockpos * MAP_BLOCKSIZE; - MapNode n0 = vmanip.getNodeNoEx(blockpos_nodes + p); + MapNode &n0 = vmanip.getNodeRefUnsafe(blockpos_nodes + p); // Don't even try to get n1 if n0 is already CONTENT_IGNORE - if (n0.getContent() == CONTENT_IGNORE ) { + if (n0.getContent() == CONTENT_IGNORE) { + makes_face = false; + return; + } + + const MapNode &n1 = vmanip.getNodeRefUnsafeCheckFlags(blockpos_nodes + p + face_dir); + + if (n1.getContent() == CONTENT_IGNORE) { makes_face = false; return; } - MapNode n1 = vmanip.getNodeNoEx(blockpos_nodes + p + face_dir); // This is hackish bool equivalent = false; @@ -1004,18 +1029,32 @@ static void updateAllFastFaceRows(MeshMakeData *data, MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): m_mesh(new scene::SMesh()), + m_minimap_mapblock(NULL), m_gamedef(data->m_gamedef), + m_tsrc(m_gamedef->getTextureSource()), + m_shdrsrc(m_gamedef->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"); + + 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) //TimeTaker timer1("MapBlockMesh()"); std::vector fastfaces_new; + fastfaces_new.reserve(512); /* We are including the faces of the trailing edges of the block. @@ -1077,21 +1116,15 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): 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()="<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); } @@ -1125,36 +1158,43 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): 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++) { + video::S3DVertexTangents *vertex = &p.vertices[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; + video::SColor &vc = vertex->Color; if (!vc.getBlue()) { - if (p.vertices[j].Normal.Y < -0.5) { + if (vertex->Normal.Y < -0.5) { applyFacesShading (vc, 0.447213); - } else if (p.vertices[j].Normal.X > 0.5) { + } else if (vertex->Normal.X > 0.5) { applyFacesShading (vc, 0.670820); - } else if (p.vertices[j].Normal.X < -0.5) { + } else if (vertex->Normal.X < -0.5) { applyFacesShading (vc, 0.670820); - } else if (p.vertices[j].Normal.Z > 0.5) { + } else if (vertex->Normal.Z > 0.5) { applyFacesShading (vc, 0.836660); - } else if (p.vertices[j].Normal.Z < -0.5) { + } else if (vertex->Normal.Z < -0.5) { 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 @@ -1163,38 +1203,34 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): 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 = 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 { - material.setTexture(2, tsrc->getTexture("disable_img.png")); + p.tile.applyMaterialOptions(material); } - } else { - p.tile.applyMaterialOptions(material); } - // Create meshbuffer - // This is a "Standard MeshBuffer", - // it's a typedeffed CMeshBuffer - 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(), - &p.indices[0], p.indices.size()); - } - + // Create meshbuffer + scene::SMeshBufferTangents *buf = new scene::SMeshBufferTangents(); + // 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(), + &p.indices[0], p.indices.size()); +} m_camera_offset = camera_offset; /* @@ -1203,6 +1239,11 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): translateMesh(m_mesh, intToFloat(data->m_blockpos * MAP_BLOCKSIZE - camera_offset, BS)); + if (m_enable_shaders) { + scene::IMeshManipulator* meshmanip = m_gamedef->getSceneManager()->getMeshManipulator(); + meshmanip->recalculateTangents(m_mesh, true, false, false); + } + if(m_mesh) { #if 0 @@ -1229,19 +1270,19 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data, v3s16 camera_offset): 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() { m_mesh->drop(); m_mesh = NULL; + delete m_minimap_mapblock; } bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_ratio) { - bool enable_shaders = g_settings->getBool("enable_shaders"); - if(!m_has_animation) { m_animation_force_timer = 100000; @@ -1255,18 +1296,17 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat { for(std::map::iterator i = m_crack_materials.begin(); - i != m_crack_materials.end(); i++) + 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<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, @@ -1288,7 +1328,7 @@ bool MapBlockMesh::animate(bool faraway, float time, int crack, u32 daynight_rat // Texture animation for(std::map::iterator i = m_animation_tiles.begin(); - i != m_animation_tiles.end(); i++) + i != m_animation_tiles.end(); ++i) { const TileSpec &tile = i->second; // Figure out current frame @@ -1302,43 +1342,62 @@ 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); - 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")); - } else { - buf->getMaterial().setTexture(2, tsrc->getTexture("disable_img.png")); } + buf->getMaterial().setTexture(2, animation_frame.flags_texture); } } // Day-night transition - if(daynight_ratio != m_last_daynight_ratio) + if(!m_enable_shaders && (daynight_ratio != m_last_daynight_ratio)) { for(std::map > >::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(); + video::S3DVertexTangents *vertices = (video::S3DVertexTangents *)buf->getVertices(); for(std::map >::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); + finalColorBlend(vertices[j->first].Color, day, night, daynight_ratio); } } 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::iterator + i = m_highlighted_materials.begin(); + i != m_highlighted_materials.end(); ++i) + { + scene::IMeshBuffer *buf = m_mesh->getMeshBuffer(*i); + video::S3DVertexTangents *vertices = (video::S3DVertexTangents*)buf->getVertices(); + for (u32 j = 0; j < buf->getVertexCount() ;j++) + vertices[j].Color = hc; + } + } + return true; } @@ -1358,15 +1417,59 @@ void MeshCollector::append(const TileSpec &tile, const video::S3DVertex *vertices, u32 numVertices, const u16 *indices, u32 numIndices) { - if(numIndices > 65535) - { + if (numIndices > 65535) { dstream<<"FIXME: MeshCollector::append() called with 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::S3DVertexTangents vert(vertices[i].Pos, vertices[i].Normal, + vertices[i].Color, vertices[i].TCoords); + p->vertices.push_back(vert); + } +} + +/* + 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="<vertices.size(); - for(u32 i=0; iindices.push_back(j); } - for(u32 i=0; ivertices.push_back(vertices[i]); + + for (u32 i = 0; i < numVertices; i++) { + video::S3DVertexTangents vert(vertices[i].Pos + pos, vertices[i].Normal, + c, vertices[i].TCoords); + p->vertices.push_back(vert); } }