#include "mapblock.h"
#include "map.h"
-// For g_materials
+// For g_settings
#include "main.h"
#include "light.h"
#include <sstream>
-
/*
MapBlock
*/
-MapBlock::MapBlock(NodeContainer *parent, v3s16 pos, bool dummy):
+MapBlock::MapBlock(Map *parent, v3s16 pos, bool dummy):
m_parent(parent),
m_pos(pos),
- changed(true),
+ m_modified(MOD_STATE_WRITE_NEEDED),
is_underground(false),
+ m_lighting_expired(true),
m_day_night_differs(false),
- m_objects(this)
+ m_generated(false),
+ m_objects(this),
+ m_timestamp(BLOCK_TIMESTAMP_UNDEFINED),
+ m_usage_timer(0)
{
data = NULL;
if(dummy == false)
reallocate();
- m_spawn_timer = -10000;
+ //m_spawn_timer = -10000;
#ifndef SERVER
m_mesh_expired = false;
}
}
-/*
- Parameters must consist of air and !air.
- Order doesn't matter.
-
- If either of the nodes doesn't exist, light is 0.
-
- parameters:
- daynight_ratio: 0...1000
- n: getNodeParent(p)
- n2: getNodeParent(p + face_dir)
- face_dir: axis oriented unit vector from p to p2
-*/
-u8 MapBlock::getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
- v3s16 face_dir)
-{
- try{
- u8 light;
- u8 l1 = n.getLightBlend(daynight_ratio);
- u8 l2 = n2.getLightBlend(daynight_ratio);
- if(l1 > l2)
- light = l1;
- else
- light = l2;
-
- // Make some nice difference to different sides
-
- /*if(face_dir.X == 1 || face_dir.Z == 1 || face_dir.Y == -1)
- light = diminish_light(diminish_light(light));
- else if(face_dir.X == -1 || face_dir.Z == -1)
- light = diminish_light(light);*/
-
- if(face_dir.X == 1 || face_dir.X == -1 || face_dir.Y == -1)
- light = diminish_light(diminish_light(light));
- else if(face_dir.Z == 1 || face_dir.Z == -1)
- light = diminish_light(light);
-
- return light;
- }
- catch(InvalidPositionException &e)
- {
- return 0;
- }
-}
-
#ifndef SERVER
-void MapBlock::makeFastFace(TileSpec tile, u8 light, v3f p,
- v3s16 dir, v3f scale, v3f posRelative_f,
- core::array<FastFace> &dest)
-{
- FastFace face;
-
- // Position is at the center of the cube.
- v3f pos = p * BS;
- posRelative_f *= BS;
-
- v3f vertex_pos[4];
- // If looking towards z+, this is the face that is behind
- // the center point, facing towards z+.
- vertex_pos[0] = v3f( BS/2,-BS/2,BS/2);
- vertex_pos[1] = v3f(-BS/2,-BS/2,BS/2);
- vertex_pos[2] = v3f(-BS/2, BS/2,BS/2);
- vertex_pos[3] = v3f( BS/2, BS/2,BS/2);
-
- if(dir == v3s16(0,0,1))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateXZBy(0);
- }
- else if(dir == v3s16(0,0,-1))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateXZBy(180);
- }
- else if(dir == v3s16(1,0,0))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateXZBy(-90);
- }
- else if(dir == v3s16(-1,0,0))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateXZBy(90);
- }
- else if(dir == v3s16(0,1,0))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateYZBy(-90);
- }
- else if(dir == v3s16(0,-1,0))
- {
- for(u16 i=0; i<4; i++)
- vertex_pos[i].rotateYZBy(90);
- }
-
- for(u16 i=0; i<4; i++)
- {
- vertex_pos[i].X *= scale.X;
- vertex_pos[i].Y *= scale.Y;
- vertex_pos[i].Z *= scale.Z;
- vertex_pos[i] += pos + posRelative_f;
- }
-
- f32 abs_scale = 1.;
- if (scale.X < 0.999 || scale.X > 1.001) abs_scale = scale.X;
- else if(scale.Y < 0.999 || scale.Y > 1.001) abs_scale = scale.Y;
- else if(scale.Z < 0.999 || scale.Z > 1.001) abs_scale = scale.Z;
-
- v3f zerovector = v3f(0,0,0);
-
- //u8 li = decode_light(light);
- u8 li = light;
-
- u8 alpha = 255;
-
- if(tile.id == TILE_WATER)
- {
- alpha = 128;
- }
-
- video::SColor c = video::SColor(alpha,li,li,li);
-
- face.vertices[0] = video::S3DVertex(vertex_pos[0], zerovector, c,
- core::vector2d<f32>(0,1));
- face.vertices[1] = video::S3DVertex(vertex_pos[1], zerovector, c,
- core::vector2d<f32>(abs_scale,1));
- face.vertices[2] = video::S3DVertex(vertex_pos[2], zerovector, c,
- core::vector2d<f32>(abs_scale,0));
- face.vertices[3] = video::S3DVertex(vertex_pos[3], zerovector, c,
- core::vector2d<f32>(0,0));
-
- face.tile = tile;
- //DEBUG
- //f->tile = TILE_STONE;
-
- dest.push_back(face);
- //return f;
-}
-
-/*
- Gets node tile from any place relative to block.
- Returns TILE_NODE if doesn't exist or should not be drawn.
-*/
-TileSpec MapBlock::getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir)
-{
- TileSpec spec;
-
- /*//DEBUG
- {
- spec.id = TILE_STONE;
- return spec;
- }*/
-
- spec.feature = TILEFEAT_NONE;
- //spec.id = TILE_STONE;
- spec.id = mn.getTile(face_dir);
-
- /*
- Check temporary modifications on this node
- */
- core::map<v3s16, NodeMod>::Node *n;
- n = m_temp_mods.find(p);
-
- // If modified
- if(n != NULL)
- {
- struct NodeMod mod = n->getValue();
- if(mod.type == NODEMOD_CHANGECONTENT)
- {
- spec.id = content_tile(mod.param, face_dir);
- }
- if(mod.type == NODEMOD_CRACK)
- {
- spec.feature = TILEFEAT_CRACK;
- spec.param.crack.progression = mod.param;
- }
- }
-
- return spec;
-}
-
-u8 MapBlock::getNodeContent(v3s16 p, MapNode mn)
-{
- /*
- Check temporary modifications on this node
- */
- core::map<v3s16, NodeMod>::Node *n;
- n = m_temp_mods.find(p);
-
- // If modified
- if(n != NULL)
- {
- struct NodeMod mod = n->getValue();
- if(mod.type == NODEMOD_CHANGECONTENT)
- {
- // Overrides content
- return mod.param;
- }
- if(mod.type == NODEMOD_CRACK)
- {
- /*
- Content doesn't change.
-
- face_contents works just like it should, because
- there should not be faces between differently cracked
- nodes.
-
- If a semi-transparent node is cracked in front an
- another one, it really doesn't matter whether there
- is a cracked face drawn in between or not.
- */
- }
- }
-
- return mn.d;
-}
-
-/*
- startpos:
- translate_dir: unit vector with only one of x, y or z
- face_dir: unit vector with only one of x, y or z
-*/
-void MapBlock::updateFastFaceRow(
- u32 daynight_ratio,
- v3f posRelative_f,
- v3s16 startpos,
- u16 length,
- v3s16 translate_dir,
- v3f translate_dir_f,
- v3s16 face_dir,
- v3f face_dir_f,
- core::array<FastFace> &dest)
-{
- v3s16 p = startpos;
-
- u16 continuous_tiles_count = 0;
-
- MapNode n0 = getNodeParentNoEx(p);
- MapNode n1 = getNodeParentNoEx(p + face_dir);
-
- u8 light = getFaceLight(daynight_ratio, n0, n1, face_dir);
-
- TileSpec tile0 = getNodeTile(n0, p, face_dir);
- TileSpec tile1 = getNodeTile(n1, p + face_dir, -face_dir);
-
- for(u16 j=0; j<length; j++)
- {
- bool next_is_different = true;
-
- v3s16 p_next;
- MapNode n0_next;
- MapNode n1_next;
- TileSpec tile0_next;
- TileSpec tile1_next;
- u8 light_next = 0;
-
- if(j != length - 1)
- {
- p_next = p + translate_dir;
- n0_next = getNodeParentNoEx(p_next);
- n1_next = getNodeParentNoEx(p_next + face_dir);
- tile0_next = getNodeTile(n0_next, p_next, face_dir);
- tile1_next = getNodeTile(n1_next, p_next + face_dir, -face_dir);
- light_next = getFaceLight(daynight_ratio, n0_next, n1_next, face_dir);
-
- if(tile0_next == tile0
- && tile1_next == tile1
- && light_next == light)
- {
- next_is_different = false;
- }
- }
-
- continuous_tiles_count++;
-
- if(next_is_different)
- {
- /*
- Create a face if there should be one
- */
- //u8 mf = face_contents(tile0, tile1);
- // This is hackish
- u8 content0 = getNodeContent(p, n0);
- u8 content1 = getNodeContent(p + face_dir, n1);
- u8 mf = face_contents(content0, content1);
-
- if(mf != 0)
- {
- // Floating point conversion of the position vector
- v3f pf(p.X, p.Y, p.Z);
- // Center point of face (kind of)
- v3f sp = pf - ((f32)continuous_tiles_count / 2. - 0.5) * translate_dir_f;
- v3f scale(1,1,1);
- if(translate_dir.X != 0){
- scale.X = continuous_tiles_count;
- }
- if(translate_dir.Y != 0){
- scale.Y = continuous_tiles_count;
- }
- if(translate_dir.Z != 0){
- scale.Z = continuous_tiles_count;
- }
-
- //FastFace *f;
-
- // If node at sp (tile0) is more solid
- if(mf == 1)
- {
- makeFastFace(tile0, decode_light(light),
- sp, face_dir, scale,
- posRelative_f, dest);
- }
- // If node at sp is less solid (mf == 2)
- else
- {
- makeFastFace(tile1, decode_light(light),
- sp+face_dir_f, -face_dir, scale,
- posRelative_f, dest);
- }
- //dest.push_back(f);
- }
-
- continuous_tiles_count = 0;
- n0 = n0_next;
- n1 = n1_next;
- tile0 = tile0_next;
- tile1 = tile1_next;
- light = light_next;
- }
-
- p = p_next;
- }
-}
-
-/*
- This is used because CMeshBuffer::append() is very slow
-*/
-struct PreMeshBuffer
-{
- video::SMaterial material;
- core::array<u16> indices;
- core::array<video::S3DVertex> vertices;
-};
-
-class MeshCollector
-{
-public:
- void append(
- video::SMaterial material,
- const video::S3DVertex* const vertices,
- u32 numVertices,
- const u16* const indices,
- u32 numIndices
- )
- {
- PreMeshBuffer *p = NULL;
- for(u32 i=0; i<m_prebuffers.size(); i++)
- {
- PreMeshBuffer &pp = m_prebuffers[i];
- if(pp.material != material)
- continue;
-
- p = &pp;
- break;
- }
-
- if(p == NULL)
- {
- PreMeshBuffer pp;
- pp.material = material;
- m_prebuffers.push_back(pp);
- p = &m_prebuffers[m_prebuffers.size()-1];
- }
-
- u32 vertex_count = p->vertices.size();
- for(u32 i=0; i<numIndices; i++)
- {
- u32 j = indices[i] + vertex_count;
- if(j > 65535)
- {
- dstream<<"FIXME: Meshbuffer ran out of indices"<<std::endl;
- // NOTE: Fix is to just add an another MeshBuffer
- }
- p->indices.push_back(j);
- }
- for(u32 i=0; i<numVertices; i++)
- {
- p->vertices.push_back(vertices[i]);
- }
- }
-
- void fillMesh(scene::SMesh *mesh)
- {
- /*dstream<<"Filling mesh with "<<m_prebuffers.size()
- <<" meshbuffers"<<std::endl;*/
- for(u32 i=0; i<m_prebuffers.size(); i++)
- {
- PreMeshBuffer &p = m_prebuffers[i];
-
- /*dstream<<"p.vertices.size()="<<p.vertices.size()
- <<", p.indices.size()="<<p.indices.size()
- <<std::endl;*/
-
- // Create meshbuffer
-
- // This is a "Standard MeshBuffer",
- // it's a typedeffed CMeshBuffer<video::S3DVertex>
- scene::SMeshBuffer *buf = new scene::SMeshBuffer();
- // Set material
- buf->Material = p.material;
- //((scene::SMeshBuffer*)buf)->Material = p.material;
- // Use VBO
- //buf->setHardwareMappingHint(scene::EHM_STATIC);
- // Add to mesh
- mesh->addMeshBuffer(buf);
- // Mesh grabbed it
- buf->drop();
-
- buf->append(p.vertices.pointer(), p.vertices.size(),
- p.indices.pointer(), p.indices.size());
- }
- }
-
-private:
- core::array<PreMeshBuffer> m_prebuffers;
-};
-
+#if 1
void MapBlock::updateMesh(u32 daynight_ratio)
{
#if 0
return;
}
#endif
-
- // 4-21ms
- //TimeTaker timer1("updateMesh()", g_device);
-
- core::array<FastFace> fastfaces_new;
-
- v3f posRelative_f(getPosRelative().X, getPosRelative().Y,
- getPosRelative().Z); // floating point conversion
-
- /*
- We are including the faces of the trailing edges of the block.
- This means that when something changes, the caller must
- also update the meshes of the blocks at the leading edges.
-
- NOTE: This is the slowest part of this method.
- */
-
- {
- // Lock this, as m_temp_mods will be used directly
- JMutexAutoLock lock(m_temp_mods_mutex);
-
- /*
- Go through every y,z and get top faces in rows of x+
- */
- for(s16 y=0; y<MAP_BLOCKSIZE; y++){
- for(s16 z=0; z<MAP_BLOCKSIZE; z++){
- updateFastFaceRow(daynight_ratio, posRelative_f,
- v3s16(0,y,z), MAP_BLOCKSIZE,
- v3s16(1,0,0), //dir
- v3f (1,0,0),
- v3s16(0,1,0), //face dir
- v3f (0,1,0),
- fastfaces_new);
- }
- }
- /*
- Go through every x,y and get right faces in rows of z+
- */
- for(s16 x=0; x<MAP_BLOCKSIZE; x++){
- for(s16 y=0; y<MAP_BLOCKSIZE; y++){
- updateFastFaceRow(daynight_ratio, posRelative_f,
- v3s16(x,y,0), MAP_BLOCKSIZE,
- v3s16(0,0,1),
- v3f (0,0,1),
- v3s16(1,0,0),
- v3f (1,0,0),
- fastfaces_new);
- }
- }
- /*
- Go through every y,z and get back faces in rows of x+
- */
- for(s16 z=0; z<MAP_BLOCKSIZE; z++){
- for(s16 y=0; y<MAP_BLOCKSIZE; y++){
- updateFastFaceRow(daynight_ratio, posRelative_f,
- v3s16(0,y,z), MAP_BLOCKSIZE,
- v3s16(1,0,0),
- v3f (1,0,0),
- v3s16(0,0,1),
- v3f (0,0,1),
- fastfaces_new);
- }
- }
- }
-
- // End of slow part
-
- /*
- Convert FastFaces to SMesh
- */
- scene::SMesh *mesh_new = NULL;
+ MeshMakeData data;
+ data.fill(daynight_ratio, this);
- mesh_new = new scene::SMesh();
+ scene::SMesh *mesh_new = makeMapBlockMesh(&data);
- if(fastfaces_new.size() > 0)
- {
- MeshCollector collector;
-
- for(u32 i=0; i<fastfaces_new.size(); i++)
- {
- FastFace &f = fastfaces_new[i];
-
- const u16 indices[] = {0,1,2,2,3,0};
-
- if(f.tile.feature == TILEFEAT_NONE)
- {
- collector.append(tile_material_get(f.tile.id), f.vertices, 4,
- indices, 6);
- }
- else if(f.tile.feature == TILEFEAT_CRACK)
- {
- const char *path = tile_texture_path_get(f.tile.id);
-
- u16 progression = f.tile.param.crack.progression;
-
- std::string name = (std::string)path + "_cracked_"
- + (char)('0' + progression);
-
- TextureMod *mod = new CrackTextureMod(progression);
-
- video::ITexture *texture = g_irrlicht->getTexture(
- TextureSpec(name, path, mod));
-
- video::SMaterial material = tile_material_get(f.tile.id);
- material.setTexture(0, texture);
-
- collector.append(material, f.vertices, 4, indices, 6);
- }
- else
- {
- // No such feature
- assert(0);
- }
- }
-
- collector.fillMesh(mesh_new);
-
- // Use VBO for mesh (this just would set this for ever buffer)
- // This will lead to infinite memory usage because or irrlicht.
- //mesh_new->setHardwareMappingHint(scene::EHM_STATIC);
-
- /*std::cout<<"MapBlock has "<<fastfaces_new->getSize()<<" faces "
- <<"and uses "<<mesh_new->getMeshBufferCount()
- <<" materials (meshbuffers)"<<std::endl;*/
- }
-
/*
- Add special graphics:
- - torches
-
- TODO: Optimize by using same meshbuffer for same textures
- */
-
- for(s16 z=0; z<MAP_BLOCKSIZE; z++)
- for(s16 y=0; y<MAP_BLOCKSIZE; y++)
- for(s16 x=0; x<MAP_BLOCKSIZE; x++)
- {
- v3s16 p(x,y,z);
-
- MapNode &n = getNodeRef(x,y,z);
-
- if(n.d == CONTENT_TORCH)
- {
- //scene::IMeshBuffer *buf = new scene::SMeshBuffer();
- scene::SMeshBuffer *buf = new scene::SMeshBuffer();
- video::SColor c(255,255,255,255);
-
- video::S3DVertex vertices[4] =
- {
- video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,BS/2,0, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,BS/2,0, 0,0,0, c, 0,0),
- };
-
- v3s16 dir = unpackDir(n.dir);
-
- for(s32 i=0; i<4; i++)
- {
- if(dir == v3s16(1,0,0))
- vertices[i].Pos.rotateXZBy(0);
- if(dir == v3s16(-1,0,0))
- vertices[i].Pos.rotateXZBy(180);
- if(dir == v3s16(0,0,1))
- vertices[i].Pos.rotateXZBy(90);
- if(dir == v3s16(0,0,-1))
- vertices[i].Pos.rotateXZBy(-90);
- if(dir == v3s16(0,-1,0))
- vertices[i].Pos.rotateXZBy(45);
- if(dir == v3s16(0,1,0))
- vertices[i].Pos.rotateXZBy(-45);
-
- vertices[i].Pos += intToFloat(p + getPosRelative());
- }
-
- u16 indices[] = {0,1,2,2,3,0};
- buf->append(vertices, 4, indices, 6);
-
- // Set material
- buf->getMaterial().setFlag(video::EMF_LIGHTING, false);
- buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false);
- buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
- //buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
- buf->getMaterial().MaterialType
- = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- if(dir == v3s16(0,-1,0))
- buf->getMaterial().setTexture(0,
- g_irrlicht->getTexture(porting::getDataPath("torch_on_floor.png").c_str()));
- else if(dir == v3s16(0,1,0))
- buf->getMaterial().setTexture(0,
- g_irrlicht->getTexture(porting::getDataPath("torch_on_ceiling.png").c_str()));
- // For backwards compatibility
- else if(dir == v3s16(0,0,0))
- buf->getMaterial().setTexture(0,
- g_irrlicht->getTexture(porting::getDataPath("torch_on_floor.png").c_str()));
- else
- buf->getMaterial().setTexture(0,
- g_irrlicht->getTexture(porting::getDataPath("torch.png").c_str()));
-
- // Add to mesh
- mesh_new->addMeshBuffer(buf);
- buf->drop();
- }
- }
-
- /*
- Do some stuff to the mesh
- */
-
- mesh_new->recalculateBoundingBox();
-
- /*
- Delete new mesh if it is empty
+ Replace the mesh
*/
- if(mesh_new->getMeshBufferCount() == 0)
- {
- mesh_new->drop();
- mesh_new = NULL;
- }
+ replaceMesh(mesh_new);
- /*
- Replace the mesh
- */
+}
+#endif
+void MapBlock::replaceMesh(scene::SMesh *mesh_new)
+{
mesh_mutex.Lock();
//scene::SMesh *mesh_old = mesh[daynight_i];
}
mesh_mutex.Unlock();
-
- //std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
}
-
-/*void MapBlock::updateMeshes(s32 first_i)
-{
- assert(first_i >= 0 && first_i <= DAYNIGHT_CACHE_COUNT);
- updateMesh(first_i);
- for(s32 i=0; i<DAYNIGHT_CACHE_COUNT; i++)
- {
- if(i == first_i)
- continue;
- updateMesh(i);
- }
-}*/
-
+
#endif // !SERVER
/*
Propagates sunlight down through the block.
Doesn't modify nodes that are not affected by sunlight.
- Returns false if sunlight at bottom block is invalid
+ Returns false if sunlight at bottom block is invalid.
+ Returns true if sunlight at bottom block is valid.
Returns true if bottom block doesn't exist.
If there is a block above, continues from it.
If there is no block above, assumes there is sunlight, unless
- is_underground is set.
+ is_underground is set or highest node is water.
+
+ All sunlighted nodes are added to light_sources.
- At the moment, all sunlighted nodes are added to light_sources.
- - SUGG: This could be optimized
+ if remove_light==true, sets non-sunlighted nodes black.
- Turns sunglighted mud into grass.
+ if black_air_left!=NULL, it is set to true if non-sunlighted
+ air is left in block.
*/
-bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources)
+bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources,
+ bool remove_light, bool *black_air_left)
{
// Whether the sunlight at the top of the bottom block is valid
bool block_below_is_valid = true;
{
for(s16 z=0; z<MAP_BLOCKSIZE; z++)
{
+#if 1
bool no_sunlight = false;
bool no_top_block = false;
// Check if node above block has sunlight
try{
MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z));
- if(n.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
+ if(n.getContent() == CONTENT_IGNORE)
+ {
+ // Trust heuristics
+ no_sunlight = is_underground;
+ }
+ else if(n.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
{
no_sunlight = true;
}
{
no_sunlight = true;
}
-
- // NOTE: As of now, it just would make everything dark.
+ else
+ {
+ MapNode n = getNode(v3s16(x, MAP_BLOCKSIZE-1, z));
+ //if(n.getContent() == CONTENT_WATER || n.getContent() == CONTENT_WATERSOURCE)
+ if(content_features(n).sunlight_propagates == false)
+ {
+ no_sunlight = true;
+ }
+ }
+ // NOTE: As of now, this just would make everything dark.
// No sunlight here
//no_sunlight = true;
}
+#endif
+#if 0 // Doesn't work; nothing gets light.
+ bool no_sunlight = true;
+ bool no_top_block = false;
+ // Check if node above block has sunlight
+ try{
+ MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z));
+ if(n.getLight(LIGHTBANK_DAY) == LIGHT_SUN)
+ {
+ no_sunlight = false;
+ }
+ }
+ catch(InvalidPositionException &e)
+ {
+ no_top_block = true;
+ }
+#endif
/*std::cout<<"("<<x<<","<<z<<"): "
<<"no_top_block="<<no_top_block
s16 y = MAP_BLOCKSIZE-1;
- if(no_sunlight == false)
+ // This makes difference to diminishing in water.
+ bool stopped_to_solid_object = false;
+
+ u8 current_light = no_sunlight ? 0 : LIGHT_SUN;
+
+ for(; y >= 0; y--)
{
- // Continue spreading sunlight downwards through transparent
- // nodes
- for(; y >= 0; y--)
+ v3s16 pos(x, y, z);
+ MapNode &n = getNodeRef(pos);
+
+ if(current_light == 0)
{
- v3s16 pos(x, y, z);
-
- MapNode &n = getNodeRef(pos);
-
- if(n.sunlight_propagates())
- {
- n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
-
- light_sources.insert(pos_relative + pos, true);
- }
- else
+ // Do nothing
+ }
+ else if(current_light == LIGHT_SUN && n.sunlight_propagates())
+ {
+ // Do nothing: Sunlight is continued
+ }
+ else if(n.light_propagates() == false)
+ {
+ /*// DEPRECATED TODO: REMOVE
+ if(grow_grass)
{
+ bool upper_is_air = false;
+ try
+ {
+ if(getNodeParent(pos+v3s16(0,1,0)).getContent() == CONTENT_AIR)
+ upper_is_air = true;
+ }
+ catch(InvalidPositionException &e)
+ {
+ }
// Turn mud into grass
- if(n.d == CONTENT_MUD)
+ if(upper_is_air && n.getContent() == CONTENT_MUD
+ && current_light == LIGHT_SUN)
{
n.d = CONTENT_GRASS;
}
+ }*/
- // Sunlight goes no further
- break;
- }
+ // A solid object is on the way.
+ stopped_to_solid_object = true;
+
+ // Light stops.
+ current_light = 0;
+ }
+ else
+ {
+ // Diminish light
+ current_light = diminish_light(current_light);
}
- }
- bool sunlight_should_go_down = (y==-1);
+ u8 old_light = n.getLight(LIGHTBANK_DAY);
- // Fill rest with black (only transparent ones)
- for(; y >= 0; y--){
- v3s16 pos(x, y, z);
+ if(current_light > old_light || remove_light)
+ {
+ n.setLight(LIGHTBANK_DAY, current_light);
+ }
- MapNode &n = getNodeRef(pos);
-
- if(n.light_propagates())
+ if(diminish_light(current_light) != 0)
{
- n.setLight(LIGHTBANK_DAY, 0);
+ light_sources.insert(pos_relative + pos, true);
}
- else{
- break;
+
+ if(current_light == 0 && stopped_to_solid_object)
+ {
+ if(black_air_left)
+ {
+ *black_air_left = true;
+ }
}
}
+ // Whether or not the block below should see LIGHT_SUN
+ bool sunlight_should_go_down = (current_light == LIGHT_SUN);
+
/*
If the block below hasn't already been marked invalid:
return block_below_is_valid;
}
+
void MapBlock::copyTo(VoxelManipulator &dst)
{
v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
+ // Copy from data to VoxelManipulator
dst.copyFrom(data, data_area, v3s16(0,0,0),
getPosRelative(), data_size);
}
-/*void getPseudoObjects(v3f origin, f32 max_d,
- core::array<DistanceSortedObject> &dest)
+void MapBlock::copyFrom(VoxelManipulator &dst)
{
-}*/
+ v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
+ VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
+
+ // Copy from VoxelManipulator to data
+ dst.copyTo(data, data_area, v3s16(0,0,0),
+ getPosRelative(), data_size);
+}
+
void MapBlock::stepObjects(float dtime, bool server, u32 daynight_ratio)
{
/*
Step objects
*/
m_objects.step(dtime, server, daynight_ratio);
-
- /*
- Spawn some objects at random.
-
- Use dayNightDiffed() to approximate being near ground level
- */
- if(m_spawn_timer < -999)
- {
- m_spawn_timer = 60;
- }
- if(dayNightDiffed() == true && getObjectCount() == 0)
- {
- m_spawn_timer -= dtime;
- if(m_spawn_timer <= 0.0)
- {
- m_spawn_timer += myrand() % 300;
-
- v2s16 p2d(
- (myrand()%(MAP_BLOCKSIZE-1))+0,
- (myrand()%(MAP_BLOCKSIZE-1))+0
- );
-
- s16 y = getGroundLevel(p2d);
-
- if(y >= 0)
- {
- v3s16 p(p2d.X, y+1, p2d.Y);
-
- if(getNode(p).d == CONTENT_AIR
- && getNode(p).getLightBlend(daynight_ratio) <= 11)
- {
- RatObject *obj = new RatObject(NULL, -1, intToFloat(p));
- addObject(obj);
- }
- }
- }
- }
setChangedFlag();
}
for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
{
MapNode &n = data[i];
- if(n.d != CONTENT_AIR)
+ if(n.getContent() != CONTENT_AIR)
{
only_air = false;
break;
s16 y = MAP_BLOCKSIZE-1;
for(; y>=0; y--)
{
- if(is_ground_content(getNodeRef(p2d.X, y, p2d.Y).d))
+ MapNode n = getNodeRef(p2d.X, y, p2d.Y);
+ if(content_features(n).walkable)
{
if(y == MAP_BLOCKSIZE-1)
return -2;
SharedBuffer<u8> materialdata(nodecount);
for(u32 i=0; i<nodecount; i++)
{
- materialdata[i] = data[i].d;
+ materialdata[i] = data[i].param0;
}
compress(materialdata, os, version);
SharedBuffer<u8> lightdata(nodecount);
for(u32 i=0; i<nodecount; i++)
{
- lightdata[i] = data[i].param;
+ lightdata[i] = data[i].param1;
}
compress(lightdata, os, version);
if(version >= 10)
{
- // Get and compress pressure
- SharedBuffer<u8> pressuredata(nodecount);
+ // Get and compress param2
+ SharedBuffer<u8> param2data(nodecount);
for(u32 i=0; i<nodecount; i++)
{
- pressuredata[i] = data[i].pressure;
+ param2data[i] = data[i].param2;
}
- compress(pressuredata, os, version);
+ compress(param2data, os, version);
}
}
// All other versions (newest)
// First byte
u8 flags = 0;
if(is_underground)
- flags |= 1;
+ flags |= 0x01;
if(m_day_night_differs)
- flags |= 2;
+ flags |= 0x02;
+ if(m_lighting_expired)
+ flags |= 0x04;
+ if(version >= 18)
+ {
+ if(m_generated == false)
+ flags |= 0x08;
+ }
os.write((char*)&flags, 1);
u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
Get data
*/
- SharedBuffer<u8> databuf(nodecount*3);
-
- // Get contents
- for(u32 i=0; i<nodecount; i++)
- {
- databuf[i] = data[i].d;
- }
-
- // Get params
+ // Serialize nodes
+ SharedBuffer<u8> databuf_nodelist(nodecount*3);
for(u32 i=0; i<nodecount; i++)
{
- databuf[i+nodecount] = data[i].param;
+ data[i].serialize(&databuf_nodelist[i*3], version);
}
-
- // Get pressure
+
+ // Create buffer with different parameters sorted
+ SharedBuffer<u8> databuf(nodecount*3);
for(u32 i=0; i<nodecount; i++)
{
- databuf[i+nodecount*2] = data[i].pressure;
+ databuf[i] = databuf_nodelist[i*3];
+ databuf[i+nodecount] = databuf_nodelist[i*3+1];
+ databuf[i+nodecount*2] = databuf_nodelist[i*3+2];
}
/*
*/
compress(databuf, os, version);
+
+ /*
+ NodeMetadata
+ */
+ if(version >= 14)
+ {
+ if(version <= 15)
+ {
+ try{
+ std::ostringstream oss(std::ios_base::binary);
+ m_node_metadata.serialize(oss);
+ os<<serializeString(oss.str());
+ }
+ // This will happen if the string is longer than 65535
+ catch(SerializationError &e)
+ {
+ // Use an empty string
+ os<<serializeString("");
+ }
+ }
+ else
+ {
+ std::ostringstream oss(std::ios_base::binary);
+ m_node_metadata.serialize(oss);
+ compressZlib(oss.str(), os);
+ //os<<serializeLongString(oss.str());
+ }
+ }
}
}
if(!ser_ver_supported(version))
throw VersionMismatchException("ERROR: MapBlock format not supported");
+ // These have no lighting info
+ if(version <= 1)
+ {
+ setLightingExpired(true);
+ }
+
+ // These have no "generated" field
+ if(version < 18)
+ {
+ m_generated = true;
+ }
+
// These have no compression
if(version <= 3 || version == 5 || version == 6)
{
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].d = s[i];
+ data[i].param0 = s[i];
}
}
{
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].param = s[i];
+ data[i].param1 = s[i];
}
}
if(version >= 10)
{
- // Uncompress and set pressure data
+ // Uncompress and set param2 data
std::ostringstream os(std::ios_base::binary);
decompress(is, os, version);
std::string s = os.str();
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].pressure = s[i];
+ data[i].param2 = s[i];
}
}
}
u8 flags;
is.read((char*)&flags, 1);
- is_underground = (flags & 1) ? true : false;
- m_day_night_differs = (flags & 2) ? true : false;
+ is_underground = (flags & 0x01) ? true : false;
+ m_day_night_differs = (flags & 0x02) ? true : false;
+ m_lighting_expired = (flags & 0x04) ? true : false;
+ if(version >= 18)
+ m_generated = (flags & 0x08) ? false : true;
// Uncompress data
std::ostringstream os(std::ios_base::binary);
std::string s = os.str();
if(s.size() != nodecount*3)
throw SerializationError
- ("MapBlock::deSerialize: invalid format");
+ ("MapBlock::deSerialize: decompress resulted in size"
+ " other than nodecount*3");
- // Set contents
+ // deserialize nodes from buffer
for(u32 i=0; i<nodecount; i++)
{
- data[i].d = s[i];
+ u8 buf[3];
+ buf[0] = s[i];
+ buf[1] = s[i+nodecount];
+ buf[2] = s[i+nodecount*2];
+ data[i].deSerialize(buf, version);
}
- // Set params
- for(u32 i=0; i<nodecount; i++)
+
+ /*
+ NodeMetadata
+ */
+ if(version >= 14)
{
- data[i].param = s[i+nodecount];
+ // Ignore errors
+ try{
+ if(version <= 15)
+ {
+ std::string data = deSerializeString(is);
+ std::istringstream iss(data, std::ios_base::binary);
+ m_node_metadata.deSerialize(iss);
+ }
+ else
+ {
+ //std::string data = deSerializeLongString(is);
+ std::ostringstream oss(std::ios_base::binary);
+ decompressZlib(is, oss);
+ std::istringstream iss(oss.str(), std::ios_base::binary);
+ m_node_metadata.deSerialize(iss);
+ }
+ }
+ catch(SerializationError &e)
+ {
+ dstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
+ <<" while deserializing node metadata"<<std::endl;
+ }
}
- // Set pressure
- for(u32 i=0; i<nodecount; i++)
- {
- data[i].pressure = s[i+nodecount*2];
+ }
+}
+
+void MapBlock::serializeDiskExtra(std::ostream &os, u8 version)
+{
+ // Versions up from 9 have block objects.
+ if(version >= 9)
+ {
+ //serializeObjects(os, version); // DEPRECATED
+ // count=0
+ writeU16(os, 0);
+ }
+
+ // Versions up from 15 have static objects.
+ if(version >= 15)
+ {
+ m_static_objects.serialize(os);
+ }
+
+ // Timestamp
+ if(version >= 17)
+ {
+ writeU32(os, getTimestamp());
+ }
+}
+
+void MapBlock::deSerializeDiskExtra(std::istream &is, u8 version)
+{
+ /*
+ Versions up from 9 have block objects.
+ */
+ if(version >= 9)
+ {
+ updateObjects(is, version, NULL, 0);
+ }
+
+ /*
+ Versions up from 15 have static objects.
+ */
+ if(version >= 15)
+ {
+ m_static_objects.deSerialize(is);
+ }
+
+ // Timestamp
+ if(version >= 17)
+ {
+ setTimestamp(readU32(is));
+ }
+ else
+ {
+ setTimestamp(BLOCK_TIMESTAMP_UNDEFINED);
+ }
+}
+
+/*
+ Get a quick string to describe what a block actually contains
+*/
+std::string analyze_block(MapBlock *block)
+{
+ if(block == NULL)
+ {
+ return "NULL";
+ }
+
+ std::ostringstream desc;
+
+ v3s16 p = block->getPos();
+ char spos[20];
+ snprintf(spos, 20, "(%2d,%2d,%2d), ", p.X, p.Y, p.Z);
+ desc<<spos;
+
+ switch(block->getModified())
+ {
+ case MOD_STATE_CLEAN:
+ desc<<"CLEAN, ";
+ break;
+ case MOD_STATE_WRITE_AT_UNLOAD:
+ desc<<"WRITE_AT_UNLOAD, ";
+ break;
+ case MOD_STATE_WRITE_NEEDED:
+ desc<<"WRITE_NEEDED, ";
+ break;
+ default:
+ desc<<"unknown getModified()="+itos(block->getModified())+", ";
+ }
+
+ if(block->isGenerated())
+ desc<<"is_gen [X], ";
+ else
+ desc<<"is_gen [ ], ";
+
+ if(block->getIsUnderground())
+ desc<<"is_ug [X], ";
+ else
+ desc<<"is_ug [ ], ";
+
+#ifndef SERVER
+ if(block->getMeshExpired())
+ desc<<"mesh_exp [X], ";
+ else
+ desc<<"mesh_exp [ ], ";
+#endif
+
+ if(block->getLightingExpired())
+ desc<<"lighting_exp [X], ";
+ else
+ desc<<"lighting_exp [ ], ";
+
+ if(block->isDummy())
+ {
+ desc<<"Dummy, ";
+ }
+ else
+ {
+ // We'll just define the numbers here, don't want to include
+ // content_mapnode.h
+ const content_t content_water = 2;
+ const content_t content_watersource = 9;
+ const content_t content_tree = 0x801;
+ const content_t content_leaves = 0x802;
+ const content_t content_jungletree = 0x815;
+
+ bool full_ignore = true;
+ bool some_ignore = false;
+ bool full_air = true;
+ bool some_air = false;
+ bool trees = false;
+ bool water = false;
+ for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+ for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
+ for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
+ {
+ v3s16 p(x0,y0,z0);
+ MapNode n = block->getNode(p);
+ content_t c = n.getContent();
+ if(c == CONTENT_IGNORE)
+ some_ignore = true;
+ else
+ full_ignore = false;
+ if(c == CONTENT_AIR)
+ some_air = true;
+ else
+ full_air = false;
+ if(c == content_tree || c == content_jungletree
+ || c == content_leaves)
+ trees = true;
+ if(c == content_water
+ || c == content_watersource)
+ water = true;
}
+
+ desc<<"content {";
+
+ std::ostringstream ss;
+
+ if(full_ignore)
+ ss<<"IGNORE (full), ";
+ else if(some_ignore)
+ ss<<"IGNORE, ";
+
+ if(full_air)
+ ss<<"AIR (full), ";
+ else if(some_air)
+ ss<<"AIR, ";
+
+ if(trees)
+ ss<<"trees, ";
+ if(water)
+ ss<<"water, ";
+
+ if(ss.str().size()>=2)
+ desc<<ss.str().substr(0, ss.str().size()-2);
+
+ desc<<"}, ";
}
+
+ return desc.str().substr(0, desc.str().size()-2);
}