From 571fb14f9480a0fd70d7cfeb0484c9513153c33a Mon Sep 17 00:00:00 2001 From: Perttu Ahola Date: Mon, 13 Dec 2010 03:19:12 +0200 Subject: working nicely --- src/client.cpp | 1 + src/environment.cpp | 4 +- src/light.cpp | 43 ++++++++ src/main.cpp | 211 +++++++++++++++++++++++++++----------- src/main.h | 4 +- src/map.cpp | 182 ++++++++++++++++++++++++++------- src/mapblock.cpp | 157 +++++++++++++++++++++++------ src/mapblock.h | 9 +- src/mapblockobject.cpp | 2 +- src/mapblockobject.h | 64 ++++++++++-- src/mapnode.h | 207 +++++++++++++++++++++++++------------- src/player.cpp | 6 +- src/server.cpp | 268 ++++++++++++++++++++++--------------------------- src/server.h | 12 ++- src/test.cpp | 32 +++--- src/utility.h | 42 ++++++++ src/voxel.cpp | 73 ++++++++++---- src/voxel.h | 6 ++ 18 files changed, 928 insertions(+), 395 deletions(-) (limited to 'src') diff --git a/src/client.cpp b/src/client.cpp index 8a9c688dd..2471558f8 100644 --- a/src/client.cpp +++ b/src/client.cpp @@ -1651,6 +1651,7 @@ MapBlockObject * Client::getSelectedObject( v3f from_pos_f_on_block = from_pos_f_on_map - block_pos_f_on_map; block->getObjects(from_pos_f_on_block, max_d, objects); + //block->getPseudoObjects(from_pos_f_on_block, max_d, objects); } //dstream<<"Collected "<getNode(bottompos); - if(n.d == MATERIAL_GRASS) + if(n.d == CONTENT_GRASS) { - n.d = MATERIAL_GRASS_FOOTSTEPS; + n.d = CONTENT_GRASS_FOOTSTEPS; m_map->setNode(bottompos, n); // Update mesh on client diff --git a/src/light.cpp b/src/light.cpp index 5fd0ce54f..a9fe023ef 100644 --- a/src/light.cpp +++ b/src/light.cpp @@ -101,4 +101,47 @@ u8 light_decode_table[LIGHT_MAX+1] = 255, }; +/* +#!/usr/bin/python + +from math import * +from sys import stdout + +# We want 0 at light=0 and 255 at light=LIGHT_MAX +LIGHT_MAX = 14 +#FACTOR = 0.69 +FACTOR = 0.75 + +maxlight = 255 +minlight = 8 + +L = [] +for i in range(1,LIGHT_MAX+1): + L.append(minlight+int(round((maxlight-minlight) * FACTOR ** (i-1)))) + #L.append(int(round(255.0 * FACTOR ** (i-1)))) +L.append(minlight) + +L.reverse() +for i in L: + stdout.write(str(i)+",\n") +*/ +/*u8 light_decode_table[LIGHT_MAX+1] = +{ +8, +14, +16, +18, +22, +27, +33, +41, +52, +67, +86, +112, +147, +193, +255, +};*/ + diff --git a/src/main.cpp b/src/main.cpp index fd91ab35c..6aa95d879 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -186,13 +186,11 @@ SUGG: Implement a "Fast check queue" (a queue with a map for checking TODO: Proper looking torches. - Signs could be done in the same way? +TODO: A mapper to map contents to tile names (for each side) + Doing now: ====================================================================== -TODO: A system for showing some nodes in some other way than cubes - - Needed for torches - - Also for signs, stairs, etc - ====================================================================== */ @@ -257,22 +255,26 @@ TODO: A system for showing some nodes in some other way than cubes IrrlichtDevice *g_device = NULL; -const char *g_material_filenames[MATERIALS_COUNT] = +const char *g_content_filenames[MATERIALS_COUNT] = { "../data/stone.png", "../data/grass.png", "../data/water.png", - "../data/light.png", + "../data/torch_on_floor.png", "../data/tree.png", "../data/leaves.png", "../data/grass_footsteps.png", "../data/mese.png", "../data/mud.png", - "../data/water.png", // ocean + "../data/water.png", // CONTENT_OCEAN }; +// Material cache video::SMaterial g_materials[MATERIALS_COUNT]; -//video::SMaterial g_mesh_materials[3]; + +// Texture cache +TextureCache g_texturecache; + // All range-related stuff below is locked behind this JMutex g_range_mutex; @@ -320,20 +322,22 @@ void set_default_settings() g_settings.set("random_input", "false"); g_settings.set("client_delete_unused_sectors_timeout", "1200"); g_settings.set("max_block_send_distance", "8"); - g_settings.set("max_block_generate_distance", "5"); + g_settings.set("max_block_generate_distance", "6"); // Server stuff g_settings.set("creative_mode", "false"); - g_settings.set("heightmap_blocksize", "128"); - g_settings.set("height_randmax", "constant 70.0"); + g_settings.set("heightmap_blocksize", "32"); + g_settings.set("height_randmax", "constant 50.0"); g_settings.set("height_randfactor", "constant 0.6"); - g_settings.set("height_base", "linear 0 35 0"); + g_settings.set("height_base", "linear 0 0 0"); g_settings.set("plants_amount", "1.0"); g_settings.set("ravines_amount", "1.0"); g_settings.set("objectdata_interval", "0.2"); g_settings.set("active_object_range", "2"); g_settings.set("max_simultaneous_block_sends_per_client", "1"); g_settings.set("max_simultaneous_block_sends_server_total", "4"); + g_settings.set("disable_water_climb", "true"); + g_settings.set("endless_water", "true"); } /* @@ -673,7 +677,7 @@ public: if(counter1 < 0.0) { counter1 = 0.1*Rand(1,10); - /*if(g_selected_material < USEFUL_MATERIAL_COUNT-1) + /*if(g_selected_material < USEFUL_CONTENT_COUNT-1) g_selected_material++; else g_selected_material = 0;*/ @@ -1297,7 +1301,7 @@ int main(int argc, char *argv[]) g_materials[i].Lighting = false; g_materials[i].BackfaceCulling = false; - const char *filename = g_material_filenames[i]; + const char *filename = g_content_filenames[i]; if(filename != NULL){ video::ITexture *t = driver->getTexture(filename); if(t == NULL){ @@ -1313,9 +1317,9 @@ int main(int argc, char *argv[]) //g_materials[i].setFlag(video::EMF_FOG_ENABLE, true); } - g_materials[MATERIAL_WATER].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA; - //g_materials[MATERIAL_WATER].MaterialType = video::EMT_TRANSPARENT_ADD_COLOR; - g_materials[MATERIAL_OCEAN].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA; + g_materials[CONTENT_WATER].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA; + //g_materials[CONTENT_WATER].MaterialType = video::EMT_TRANSPARENT_ADD_COLOR; + g_materials[CONTENT_OCEAN].MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA; /*g_mesh_materials[0].setTexture(0, driver->getTexture("../data/water.png")); g_mesh_materials[1].setTexture(0, driver->getTexture("../data/grass.png")); @@ -1328,8 +1332,18 @@ int main(int argc, char *argv[]) g_mesh_materials[i].setFlag(video::EMF_FOG_ENABLE, true); }*/ - // Make a scope here for the client so that it gets removed - // before the irrlicht device + /* + Preload some random textures that are used in threads + */ + + g_texturecache.set("torch", driver->getTexture("../data/torch.png")); + g_texturecache.set("torch_on_floor", driver->getTexture("../data/torch_on_floor.png")); + g_texturecache.set("torch_on_ceiling", driver->getTexture("../data/torch_on_ceiling.png")); + + /* + Make a scope here for the client so that it gets removed + before the irrlicht device + */ { std::cout<addSkyBoxSceneNode( + driver->getTexture("../data/skybox2.png"), + driver->getTexture("../data/skybox3.png"), + driver->getTexture("../data/skybox1.png"), + driver->getTexture("../data/skybox1.png"), + driver->getTexture("../data/skybox1.png"), + driver->getTexture("../data/skybox1.png")); + /* driver->getTexture("../data/irrlicht2_up.jpg"), + driver->getTexture("../data/irrlicht2_dn.jpg"), + driver->getTexture("../data/irrlicht2_lf.jpg"), + driver->getTexture("../data/irrlicht2_rt.jpg"), + driver->getTexture("../data/irrlicht2_ft.jpg"), + driver->getTexture("../data/irrlicht2_bk.jpg"));*/ /* Create the camera node @@ -1862,14 +1893,19 @@ int main(int argc, char *argv[]) s16 zend = pos_i.Z + (camera_direction.Z>0 ? a : 1); s16 xend = pos_i.X + (camera_direction.X>0 ? a : 1); - for(s16 y = ystart; y <= yend; y++){ - for(s16 z = zstart; z <= zend; z++){ + for(s16 y = ystart; y <= yend; y++) + for(s16 z = zstart; z <= zend; z++) for(s16 x = xstart; x <= xend; x++) { - try{ - if(material_pointable(client.getNode(v3s16(x,y,z)).d) == false) + MapNode n; + try + { + n = client.getNode(v3s16(x,y,z)); + if(content_pointable(n.d) == false) continue; - }catch(InvalidPositionException &e){ + } + catch(InvalidPositionException &e) + { continue; } @@ -1878,55 +1914,110 @@ int main(int argc, char *argv[]) f32 d = 0.01; - v3s16 directions[6] = { + v3s16 dirs[6] = { v3s16(0,0,1), // back v3s16(0,1,0), // top v3s16(1,0,0), // right - v3s16(0,0,-1), - v3s16(0,-1,0), - v3s16(-1,0,0), + v3s16(0,0,-1), // front + v3s16(0,-1,0), // bottom + v3s16(-1,0,0), // left }; + + /* + Meta-objects + */ + if(n.d == CONTENT_LIGHT) + { + v3s16 dir = unpackDir(n.dir); + v3f dir_f = v3f(dir.X, dir.Y, dir.Z); + dir_f *= BS/2 - BS/6 - BS/20; + v3f cpf = npf + dir_f; + f32 distance = (cpf - camera_position).getLength(); - for(u16 i=0; i<6; i++){ - //{u16 i=3; - v3f dir_f = v3f(directions[i].X, - directions[i].Y, directions[i].Z); - v3f centerpoint = npf + dir_f * BS/2; - f32 distance = - (centerpoint - camera_position).getLength(); + core::aabbox3d box; - if(distance < mindistance){ - //std::cout< m; - m.buildRotateFromTo(v3f(0,0,1), dir_f); - - // This is the back face - v3f corners[2] = { - v3f(BS/2, BS/2, BS/2), - v3f(-BS/2, -BS/2, BS/2+d) - }; - - for(u16 j=0; j<2; j++){ - m.rotateVect(corners[j]); - corners[j] += npf; - //std::cout< facebox(corners[0],corners[1]); - core::aabbox3d facebox(corners[0]); - facebox.addInternalPoint(corners[1]); + // bottom + if(dir == v3s16(0,-1,0)) + { + box = core::aabbox3d( + npf - v3f(BS/6, BS/2, BS/6), + npf + v3f(BS/6, -BS/2+BS/3*2, BS/6) + ); + } + // top + else if(dir == v3s16(0,1,0)) + { + box = core::aabbox3d( + npf - v3f(BS/6, -BS/2+BS/3*2, BS/6), + npf + v3f(BS/6, BS/2, BS/6) + ); + } + // side + else + { + box = core::aabbox3d( + cpf - v3f(BS/6, BS/3, BS/6), + cpf + v3f(BS/6, BS/3, BS/6) + ); + } - if(facebox.intersectsWithLine(shootline)){ + if(distance < mindistance) + { + if(box.intersectsWithLine(shootline)) + { nodefound = true; nodepos = np; - neighbourpos = np + directions[i]; + neighbourpos = np; mindistance = distance; - nodefacebox = facebox; + nodefacebox = box; } } } - }}} + /* + Regular blocks + */ + else + { + for(u16 i=0; i<6; i++) + { + v3f dir_f = v3f(dirs[i].X, + dirs[i].Y, dirs[i].Z); + v3f centerpoint = npf + dir_f * BS/2; + f32 distance = + (centerpoint - camera_position).getLength(); + + if(distance < mindistance) + { + core::CMatrix4 m; + m.buildRotateFromTo(v3f(0,0,1), dir_f); + + // This is the back face + v3f corners[2] = { + v3f(BS/2, BS/2, BS/2), + v3f(-BS/2, -BS/2, BS/2+d) + }; + + for(u16 j=0; j<2; j++) + { + m.rotateVect(corners[j]); + corners[j] += npf; + } + + core::aabbox3d facebox(corners[0]); + facebox.addInternalPoint(corners[1]); + + if(facebox.intersectsWithLine(shootline)) + { + nodefound = true; + nodepos = np; + neighbourpos = np + dirs[i]; + mindistance = distance; + nodefacebox = facebox; + } + } // if distance < mindistance + } // for dirs + } // regular block + } // for coords if(nodefound) { diff --git a/src/main.h b/src/main.h index a08cff3f0..3d676bd43 100644 --- a/src/main.h +++ b/src/main.h @@ -55,7 +55,9 @@ extern std::ostream *derr_server_ptr; // This header is only for MATERIALS_COUNT #include "mapnode.h" extern video::SMaterial g_materials[MATERIALS_COUNT]; -//extern video::SMaterial g_mesh_materials[3]; + +#include "utility.h" +extern TextureCache g_texturecache; extern IrrlichtDevice *g_device; diff --git a/src/map.cpp b/src/map.cpp index 1a7cd9bb9..ff57e8d90 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -510,6 +510,10 @@ void Map::unspreadLight(core::map & from_nodes, light_sources.remove(n2pos); }*/ } + + /*// DEBUG + if(light_sources.find(n2pos) != NULL) + light_sources.remove(n2pos);*/ } else{ light_sources.insert(n2pos, true); @@ -850,8 +854,8 @@ void Map::updateLighting(core::map & a_blocks, // Collect borders for unlighting if(x==0 || x == MAP_BLOCKSIZE-1 - || y==0 || y == MAP_BLOCKSIZE-1 - || z==0 || z == MAP_BLOCKSIZE-1) + || y==0 || y == MAP_BLOCKSIZE-1 + || z==0 || z == MAP_BLOCKSIZE-1) { v3s16 p_map = p + v3s16( MAP_BLOCKSIZE*pos.X, @@ -912,6 +916,8 @@ void Map::updateLighting(core::map & a_blocks, // Yes, add it to light_sources... somehow. // It has to be added at somewhere above, in the loop. // TODO + // NOTE: This actually works quite fine without it + // - Find out why it works { //TimeTaker timer("spreadLight", g_device); @@ -1048,7 +1054,7 @@ void Map::removeNodeAndUpdate(v3s16 p, v3s16 toppos = p + v3s16(0,1,0); // Node will be replaced with this - u8 replace_material = MATERIAL_AIR; + u8 replace_material = CONTENT_AIR; // NOTE: Water is now managed elsewhere #if 0 @@ -1099,7 +1105,7 @@ void Map::removeNodeAndUpdate(v3s16 p, if( c > highest_ranking || // Prefer something else than air - (c >= highest_ranking && m != MATERIAL_AIR) + (c >= highest_ranking && m != CONTENT_AIR) ) { @@ -1722,17 +1728,91 @@ MapBlock * ServerMap::emergeBlock( low_block_is_empty = true;*/ const s32 ued = 4; + //const s32 ued = 8; bool underground_emptiness[ued*ued*ued]; for(s32 i=0; iprintHeightmaps(); @@ -1755,14 +1835,19 @@ MapBlock * ServerMap::emergeBlock( //avg_ground_y += surface_y; if(surface_y < lowest_ground_y) lowest_ground_y = surface_y; + if(surface_y > highest_ground_y) + highest_ground_y = surface_y; s32 surface_depth = 0; float slope = sector->getSlope(v2s16(x0,z0)).getLength(); - float min_slope = 0.45; - float max_slope = 0.85; - float min_slope_depth = 5.0; + //float min_slope = 0.45; + //float max_slope = 0.85; + float min_slope = 0.70; + float max_slope = 1.20; + float min_slope_depth = 4.0; + //float min_slope_depth = 5.0; float max_slope_depth = 0; if(slope < min_slope) surface_depth = min_slope_depth; @@ -1783,33 +1868,55 @@ MapBlock * ServerMap::emergeBlock( */ if(real_y > surface_y) n.setLight(LIGHT_SUN); + /* Calculate material */ + // If node is very low - if(real_y <= surface_y - 7){ + /*if(real_y <= surface_y - 7) + { // Create dungeons if(underground_emptiness[ ued*ued*(z0*ued/MAP_BLOCKSIZE) +ued*(y0*ued/MAP_BLOCKSIZE) +(x0*ued/MAP_BLOCKSIZE)]) { - n.d = MATERIAL_AIR; + n.d = CONTENT_AIR; } else { - n.d = MATERIAL_STONE; + n.d = CONTENT_STONE; } } // If node is under surface level else if(real_y <= surface_y - surface_depth) - n.d = MATERIAL_STONE; + n.d = CONTENT_STONE; + */ + if(real_y <= surface_y - surface_depth) + { + // Create dungeons + if(underground_emptiness[ + ued*ued*(z0*ued/MAP_BLOCKSIZE) + +ued*(y0*ued/MAP_BLOCKSIZE) + +(x0*ued/MAP_BLOCKSIZE)]) + { + n.d = CONTENT_AIR; + } + else + { + n.d = CONTENT_STONE; + } + } // If node is at or under heightmap y else if(real_y <= surface_y) { // If under water level, it's mud if(real_y < WATER_LEVEL) - n.d = MATERIAL_MUD; + n.d = CONTENT_MUD; + // Only the topmost node is grass + else if(real_y <= surface_y - 1) + n.d = CONTENT_MUD; // Else it's the main material else n.d = material; @@ -1819,13 +1926,12 @@ MapBlock * ServerMap::emergeBlock( // If under water level, it's water if(real_y < WATER_LEVEL) { - //n.d = MATERIAL_WATER; - n.d = MATERIAL_OCEAN; + n.d = water_material; n.setLight(diminish_light(LIGHT_SUN, WATER_LEVEL-real_y+1)); } // else air else - n.d = MATERIAL_AIR; + n.d = CONTENT_AIR; } block->setNode(v3s16(x0,y0,z0), n); } @@ -1836,15 +1942,17 @@ MapBlock * ServerMap::emergeBlock( */ // Probably underground if the highest part of block is under lowest // ground height - bool is_underground = (block_y+1) * MAP_BLOCKSIZE < lowest_ground_y; + bool is_underground = (block_y+1) * MAP_BLOCKSIZE <= lowest_ground_y; block->setIsUnderground(is_underground); /* - Force lighting update if underground. - This is needed because of ravines. + Force lighting update if some part of block is underground + This is needed because of caves. */ - - if(is_underground) + + bool some_part_underground = (block_y+0) * MAP_BLOCKSIZE < highest_ground_y; + if(some_part_underground) + //if(is_underground) { lighting_invalidated_blocks[block->getPos()] = block; } @@ -1867,15 +1975,15 @@ MapBlock * ServerMap::emergeBlock( ); MapNode n; - n.d = MATERIAL_MESE; + n.d = CONTENT_MESE; - if(is_ground_material(block->getNode(cp).d)) + if(is_ground_content(block->getNode(cp).d)) if(rand()%8 == 0) block->setNode(cp, n); for(u16 i=0; i<26; i++) { - if(is_ground_material(block->getNode(cp+g_26dirs[i]).d)) + if(is_ground_content(block->getNode(cp+g_26dirs[i]).d)) if(rand()%8 == 0) block->setNode(cp+g_26dirs[i], n); } @@ -1897,7 +2005,7 @@ MapBlock * ServerMap::emergeBlock( ); // Check that the place is empty - //if(!is_ground_material(block->getNode(cp).d)) + //if(!is_ground_content(block->getNode(cp).d)) if(1) { RatObject *obj = new RatObject(NULL, -1, intToFloat(cp)); @@ -1978,7 +2086,7 @@ MapBlock * ServerMap::emergeBlock( p + v3s16(0,0,0), &changed_blocks_sector)) { MapNode n; - n.d = MATERIAL_LIGHT; + n.d = CONTENT_LIGHT; sector->setNode(p, n); objects_to_remove.push_back(p); } @@ -1991,13 +2099,13 @@ MapBlock * ServerMap::emergeBlock( &changed_blocks_sector)) { MapNode n; - n.d = MATERIAL_TREE; + n.d = CONTENT_TREE; sector->setNode(p+v3s16(0,0,0), n); sector->setNode(p+v3s16(0,1,0), n); sector->setNode(p+v3s16(0,2,0), n); sector->setNode(p+v3s16(0,3,0), n); - n.d = MATERIAL_LEAVES; + n.d = CONTENT_LEAVES; sector->setNode(p+v3s16(0,4,0), n); @@ -2032,7 +2140,7 @@ MapBlock * ServerMap::emergeBlock( p + v3s16(0,0,0), &changed_blocks_sector)) { MapNode n; - n.d = MATERIAL_LEAVES; + n.d = CONTENT_LEAVES; sector->setNode(p+v3s16(0,0,0), n); objects_to_remove.push_back(p); @@ -2047,9 +2155,9 @@ MapBlock * ServerMap::emergeBlock( &changed_blocks_sector)) { MapNode n; - n.d = MATERIAL_STONE; + n.d = CONTENT_STONE; MapNode n2; - n2.d = MATERIAL_AIR; + n2.d = CONTENT_AIR; s16 depth = maxdepth + (rand()%10); s16 z = 0; s16 minz = -6 - (-2); @@ -2067,22 +2175,22 @@ MapBlock * ServerMap::emergeBlock( <getNode(p2).d)) + if(is_ground_content(sector->getNode(p2).d)) sector->setNode(p2, n); } { v3s16 p2 = p + v3s16(x,y,z-1); - if(is_ground_material(sector->getNode(p2).d)) + if(is_ground_content(sector->getNode(p2).d)) sector->setNode(p2, n2); } { v3s16 p2 = p + v3s16(x,y,z+0); - if(is_ground_material(sector->getNode(p2).d)) + if(is_ground_content(sector->getNode(p2).d)) sector->setNode(p2, n2); } { v3s16 p2 = p + v3s16(x,y,z+1); - if(is_ground_material(sector->getNode(p2).d)) + if(is_ground_content(sector->getNode(p2).d)) sector->setNode(p2, n); } @@ -3100,7 +3208,7 @@ void ClientMap::updateMesh() /*dstream<<"mesh_old refcount="<getReferenceCount() <getMeshBuffer - (g_materials[MATERIAL_GRASS]); + (g_materials[CONTENT_GRASS]); if(buf != NULL) dstream<<"grass buf refcount="<getReferenceCount() < n2.getLight()) light = n.getLight(); else light = n2.getLight(); @@ -173,18 +177,18 @@ u8 MapBlock::getFaceLight(v3s16 p, v3s16 face_dir) /* Gets node material from any place relative to block. - Returns MATERIAL_IGNORE if doesn't exist or should not be drawn. + Returns CONTENT_IGNORE if doesn't exist or should not be drawn. */ -u8 MapBlock::getNodeMaterial(v3s16 p) +u8 MapBlock::getNodeTile(v3s16 p) { try{ MapNode n = getNodeParent(p); - return content_cube_material(n.d); + return content_tile(n.d); } catch(InvalidPositionException &e) { - return MATERIAL_IGNORE; + return CONTENT_IGNORE; } } @@ -216,82 +220,82 @@ void MapBlock::updateFastFaceRow(v3s16 startpos, */ u8 light = getFaceLight(p, face_dir); - u16 continuous_materials_count = 0; + u16 continuous_tiles_count = 0; - u8 material0 = getNodeMaterial(p); - u8 material1 = getNodeMaterial(p + face_dir); + u8 tile0 = getNodeTile(p); + u8 tile1 = getNodeTile(p + face_dir); for(u16 j=0; jgetSize() > 0) { MeshCollector collector; @@ -467,8 +473,6 @@ void MapBlock::updateMesh() indices, 6); } - mesh_new = new scene::SMesh(); - collector.fillMesh(mesh_new); // Use VBO for mesh (this just would set this for ever buffer) @@ -495,13 +499,103 @@ void MapBlock::updateMesh() /* Add special graphics: - torches + + TODO: Optimize by using same meshbuffer for same textures */ + /*scene::ISceneManager *smgr = NULL; + video::IVideoDriver* driver = NULL; + if(g_device) + { + smgr = g_device->getSceneManager(); + driver = smgr->getVideoDriver(); + }*/ + for(s16 z=0; zappend(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_texturecache.get("torch_on_floor")); + else if(dir == v3s16(0,1,0)) + buf->getMaterial().setTexture(0, + g_texturecache.get("torch_on_ceiling")); + // For backwards compatibility + else if(dir == v3s16(0,0,0)) + buf->getMaterial().setTexture(0, + g_texturecache.get("torch_on_floor")); + else + buf->getMaterial().setTexture(0, g_texturecache.get("torch")); + + // 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 + */ + + if(mesh_new->getMeshBufferCount() == 0) + { + mesh_new->drop(); + mesh_new = NULL; } /* @@ -681,6 +775,11 @@ void MapBlock::copyTo(VoxelManipulator &dst) getPosRelative(), data_size); } +/*void getPseudoObjects(v3f origin, f32 max_d, + core::array &dest) +{ +}*/ + /* Serialization */ diff --git a/src/mapblock.h b/src/mapblock.h index c18bbb2b4..76465903b 100644 --- a/src/mapblock.h +++ b/src/mapblock.h @@ -288,11 +288,7 @@ public: u8 getFaceLight(v3s16 p, v3s16 face_dir); - /* - Gets node material from any place relative to block. - Returns MATERIAL_AIR if doesn't exist. - */ - u8 getNodeMaterial(v3s16 p); + u8 getNodeTile(v3s16 p); /* startpos: @@ -376,6 +372,9 @@ public: m_objects.getObjects(origin, max_d, dest); } + /*void getPseudoObjects(v3f origin, f32 max_d, + core::array &dest);*/ + s32 getObjectCount() { return m_objects.getCount(); diff --git a/src/mapblockobject.cpp b/src/mapblockobject.cpp index 3a28e2250..cd12feb0c 100644 --- a/src/mapblockobject.cpp +++ b/src/mapblockobject.cpp @@ -145,7 +145,7 @@ void MovingObject::move(float dtime, v3f acceleration) for(s16 x = oldpos_i.X - 1; x <= oldpos_i.X + 1; x++) { try{ - if(material_walkable(m_block->getNodeParent(v3s16(x,y,z)).d) + if(content_walkable(m_block->getNodeParent(v3s16(x,y,z)).d) == false) continue; } diff --git a/src/mapblockobject.h b/src/mapblockobject.h index 2a5f9c933..61bd6610d 100644 --- a/src/mapblockobject.h +++ b/src/mapblockobject.h @@ -28,13 +28,12 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "constants.h" #include "debug.h" -enum -{ - MAPBLOCKOBJECT_TYPE_TEST=0, - MAPBLOCKOBJECT_TYPE_TEST2=1, - MAPBLOCKOBJECT_TYPE_SIGN=2, - MAPBLOCKOBJECT_TYPE_RAT=3, -}; +#define MAPBLOCKOBJECT_TYPE_TEST 0 +#define MAPBLOCKOBJECT_TYPE_TEST2 1 +#define MAPBLOCKOBJECT_TYPE_SIGN 2 +#define MAPBLOCKOBJECT_TYPE_RAT 3 +// Used for handling selecting special stuff +//#define MAPBLOCKOBJECT_TYPE_PSEUDO 4 class MapBlock; @@ -170,6 +169,57 @@ protected: friend class MapBlockObjectList; }; +#if 0 +/* + Used for handling selections of special stuff +*/ +class PseudoMBObject : public MapBlockObject +{ +public: + // The constructor of every MapBlockObject should be like this + PseudoMBObject(MapBlock *block, s16 id, v3f pos): + MapBlockObject(block, id, pos) + { + } + virtual ~PseudoMBObject() + { + if(m_selection_box) + delete m_selection_box; + } + + /* + Implementation interface + */ + virtual u16 getTypeId() const + { + return MAPBLOCKOBJECT_TYPE_PSEUDO; + } + virtual void serialize(std::ostream &os, u8 version) + { + assert(0); + } + virtual void update(std::istream &is, u8 version) + { + assert(0); + } + virtual bool serverStep(float dtime) + { + assert(0); + } + + /* + Special methods + */ + + void setSelectionBox(core::aabbox3d box) + { + m_selection_box = new core::aabbox3d(box); + } + +protected: +}; +#endif + class TestObject : public MapBlockObject { public: diff --git a/src/mapnode.h b/src/mapnode.h index 0d65f30a4..9d9aba899 100644 --- a/src/mapnode.h +++ b/src/mapnode.h @@ -41,66 +41,68 @@ with this program; if not, write to the Free Software Foundation, Inc., Doesn't create faces with anything and is considered being out-of-map in the game map. */ -#define MATERIAL_IGNORE 255 -#define MATERIAL_IGNORE_DEFAULT_PARAM 0 +#define CONTENT_IGNORE 255 +#define CONTENT_IGNORE_DEFAULT_PARAM 0 /* The common material through which the player can walk and which is transparent to light */ -#define MATERIAL_AIR 254 +#define CONTENT_AIR 254 /* - Materials-todo: - + Suggested materials: GRAVEL - Dynamics of gravel: if there is a drop of more than two blocks on any side, it will drop in there. Is this doable? - TODO: These should be named to "content" or something like that + New naming scheme: + - Material = irrlicht's Material class + - Content = (u8) content of a node + - Tile = (u16) Material ID at some side of a node */ -enum Material +enum Content { - MATERIAL_STONE=0, + CONTENT_STONE=0, - MATERIAL_GRASS, + CONTENT_GRASS, - MATERIAL_WATER, + CONTENT_WATER, - MATERIAL_LIGHT, + CONTENT_LIGHT, - MATERIAL_TREE, + CONTENT_TREE, - MATERIAL_LEAVES, + CONTENT_LEAVES, - MATERIAL_GRASS_FOOTSTEPS, + CONTENT_GRASS_FOOTSTEPS, - MATERIAL_MESE, + CONTENT_MESE, - MATERIAL_MUD, + CONTENT_MUD, - MATERIAL_OCEAN, + CONTENT_OCEAN, // This is set to the number of the actual values in this enum - USEFUL_MATERIAL_COUNT + USEFUL_CONTENT_COUNT }; /* If true, the material allows light propagation and brightness is stored in param. */ -inline bool light_propagates_material(u8 m) +inline bool light_propagates_content(u8 m) { - return (m == MATERIAL_AIR || m == MATERIAL_LIGHT || m == MATERIAL_WATER || m == MATERIAL_OCEAN); + return (m == CONTENT_AIR || m == CONTENT_LIGHT || m == CONTENT_WATER || m == CONTENT_OCEAN); } /* If true, the material allows lossless sunlight propagation. */ -inline bool sunlight_propagates_material(u8 m) +inline bool sunlight_propagates_content(u8 m) { - return (m == MATERIAL_AIR); + return (m == CONTENT_AIR || m == CONTENT_LIGHT); } /* @@ -110,98 +112,157 @@ inline bool sunlight_propagates_material(u8 m) 1: Transparent 2: Opaque */ -inline u8 material_solidness(u8 m) +inline u8 content_solidness(u8 m) { - if(m == MATERIAL_AIR) + if(m == CONTENT_AIR) return 0; - if(m == MATERIAL_WATER || m == MATERIAL_OCEAN) + if(m == CONTENT_WATER || m == CONTENT_OCEAN) return 1; return 2; } -// Objects collide with walkable materials -inline bool material_walkable(u8 m) +// Objects collide with walkable contents +inline bool content_walkable(u8 m) { - return (m != MATERIAL_AIR && m != MATERIAL_WATER && m != MATERIAL_OCEAN && m != MATERIAL_LIGHT); + return (m != CONTENT_AIR && m != CONTENT_WATER && m != CONTENT_OCEAN && m != CONTENT_LIGHT); } // A liquid resists fast movement -inline bool material_liquid(u8 m) +inline bool content_liquid(u8 m) { - return (m == MATERIAL_WATER || m == MATERIAL_OCEAN); + return (m == CONTENT_WATER || m == CONTENT_OCEAN); } -// Pointable materials can be pointed to in the map -inline bool material_pointable(u8 m) +// Pointable contents can be pointed to in the map +inline bool content_pointable(u8 m) { - return (m != MATERIAL_AIR && m != MATERIAL_WATER && m != MATERIAL_OCEAN); + return (m != CONTENT_AIR && m != CONTENT_WATER && m != CONTENT_OCEAN); } -inline bool material_diggable(u8 m) +inline bool content_diggable(u8 m) { - return (m != MATERIAL_AIR && m != MATERIAL_WATER && m != MATERIAL_OCEAN); + return (m != CONTENT_AIR && m != CONTENT_WATER && m != CONTENT_OCEAN); } -inline bool material_buildable_to(u8 m) +inline bool content_buildable_to(u8 m) { - return (m == MATERIAL_AIR || m == MATERIAL_WATER || m == MATERIAL_OCEAN); + return (m == CONTENT_AIR || m == CONTENT_WATER || m == CONTENT_OCEAN); } /* - As of now, input is a "material" and the output is a "material" + TODO: Make a mapper class for mapping every side of a content + to some tile. + This dumbily maps all sides of content to the tile of the same id. */ -inline u8 content_cube_material(u8 c) +inline u8 content_tile(u8 c) { - if(c == MATERIAL_IGNORE || c == MATERIAL_LIGHT) - return MATERIAL_AIR; + if(c == CONTENT_IGNORE || c == CONTENT_LIGHT) + return CONTENT_AIR; return c; } /* - Returns true for materials that form the base ground that + Returns true for contents that form the base ground that follows the main heightmap */ -inline bool is_ground_material(u8 m) +inline bool is_ground_content(u8 m) { return( - m == MATERIAL_STONE || - m == MATERIAL_GRASS || - m == MATERIAL_GRASS_FOOTSTEPS || - m == MATERIAL_MESE || - m == MATERIAL_MUD + m == CONTENT_STONE || + m == CONTENT_GRASS || + m == CONTENT_GRASS_FOOTSTEPS || + m == CONTENT_MESE || + m == CONTENT_MUD ); } /* - Nodes make a face if materials differ and solidness differs. + Nodes make a face if contents differ and solidness differs. Return value: 0: No face - 1: Face uses m1's material - 2: Face uses m2's material + 1: Face uses m1's content + 2: Face uses m2's content */ -inline u8 face_materials(u8 m1, u8 m2) +inline u8 face_contents(u8 m1, u8 m2) { - if(m1 == MATERIAL_IGNORE || m2 == MATERIAL_IGNORE) + if(m1 == CONTENT_IGNORE || m2 == CONTENT_IGNORE) return 0; - bool materials_differ = (m1 != m2); - bool solidness_differs = (material_solidness(m1) != material_solidness(m2)); - bool makes_face = materials_differ && solidness_differs; + bool contents_differ = (m1 != m2); + bool solidness_differs = (content_solidness(m1) != content_solidness(m2)); + bool makes_face = contents_differ && solidness_differs; if(makes_face == false) return 0; - if(material_solidness(m1) > material_solidness(m2)) + if(content_solidness(m1) > content_solidness(m2)) return 1; else return 2; } +inline bool liquid_replaces_content(u8 c) +{ + return (c == CONTENT_AIR || c == CONTENT_LIGHT); +} + +/* + When placing a node, drection info is added to it if this is true +*/ +inline bool content_directional(u8 c) +{ + return (c == CONTENT_LIGHT); +} + +/* + Packs directions like (1,0,0), (1,-1,0) +*/ +inline u8 packDir(v3s16 dir) +{ + u8 b = 0; + + if(dir.X > 0) + b |= (1<<0); + else if(dir.X < 0) + b |= (1<<1); + + if(dir.Y > 0) + b |= (1<<2); + else if(dir.Y < 0) + b |= (1<<3); + + if(dir.Z > 0) + b |= (1<<4); + else if(dir.Z < 0) + b |= (1<<5); + + return b; +} +inline v3s16 unpackDir(u8 b) +{ + v3s16 d(0,0,0); + + if(b & (1<<0)) + d.X = 1; + else if(b & (1<<1)) + d.X = -1; + + if(b & (1<<2)) + d.Y = 1; + else if(b & (1<<3)) + d.Y = -1; + + if(b & (1<<4)) + d.Z = 1; + else if(b & (1<<5)) + d.Z = -1; + + return d; +} + struct MapNode { - //TODO: block type to differ from material - // (e.g. grass edges or something) - // block type + // Content u8 d; /* @@ -211,15 +272,27 @@ struct MapNode Sunlight is LIGHT_SUN, which is LIGHT_MAX+1. */ s8 param; + + union + { + /* + Pressure for liquids + */ + u8 pressure; - u8 pressure; + /* + Direction for torches and other stuff. + If possible, packed with packDir. + */ + u8 dir; + }; MapNode(const MapNode & n) { *this = n; } - MapNode(u8 data=MATERIAL_AIR, u8 a_param=0, u8 a_pressure=0) + MapNode(u8 data=CONTENT_AIR, u8 a_param=0, u8 a_pressure=0) { d = data; param = a_param; @@ -235,17 +308,17 @@ struct MapNode bool light_propagates() { - return light_propagates_material(d); + return light_propagates_content(d); } bool sunlight_propagates() { - return sunlight_propagates_material(d); + return sunlight_propagates_content(d); } u8 solidness() { - return material_solidness(d); + return content_solidness(d); } u8 light_source() @@ -253,7 +326,7 @@ struct MapNode /* Note that a block that isn't light_propagates() can be a light source. */ - if(d == MATERIAL_LIGHT) + if(d == CONTENT_LIGHT) return LIGHT_MAX; return 0; @@ -261,7 +334,7 @@ struct MapNode u8 getLight() { - // Select the brightest of [light_source, transparent_light] + // Select the brightest of [light source, propagated light] u8 light = 0; if(light_propagates()) light = param & 0x0f; diff --git a/src/player.cpp b/src/player.cpp index 5e838bf7a..ef2a3bdfb 100644 --- a/src/player.cpp +++ b/src/player.cpp @@ -72,12 +72,12 @@ void Player::move(f32 dtime, Map &map) if(in_water) { v3s16 pp = floatToInt(position + v3f(0,0,0)); - in_water = material_liquid(map.getNode(pp).d); + in_water = content_liquid(map.getNode(pp).d); } else { v3s16 pp = floatToInt(position + v3f(0,BS/2,0)); - in_water = material_liquid(map.getNode(pp).d); + in_water = content_liquid(map.getNode(pp).d); } } catch(InvalidPositionException &e) @@ -122,7 +122,7 @@ void Player::move(f32 dtime, Map &map) for(s16 z = oldpos_i.Z - 1; z <= oldpos_i.Z + 1; z++){ for(s16 x = oldpos_i.X - 1; x <= oldpos_i.X + 1; x++){ try{ - if(material_walkable(map.getNode(v3s16(x,y,z)).d) == false){ + if(content_walkable(map.getNode(v3s16(x,y,z)).d) == false){ continue; } } diff --git a/src/server.cpp b/src/server.cpp index e343d5947..c7b589e7a 100644 --- a/src/server.cpp +++ b/src/server.cpp @@ -94,6 +94,8 @@ void * EmergeThread::Thread() v3s16 &p = q->pos; //derr_server<<"EmergeThread::Thread(): running"<UpdateBlockWaterPressure(block, modified_blocks); + + for(core::map::Iterator i = changed_blocks.getIterator(); + i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + m_server->UpdateBlockWaterPressure(block, modified_blocks); + //v3s16 p = i.getNode()->getKey(); + //m_server->UpdateBlockWaterPressure(p, modified_blocks); + } + /* Collect a list of blocks that have been modified in addition to the fetched one. */ - // Add all the "changed blocks" + // Add all the "changed blocks" to modified_blocks for(core::map::Iterator i = changed_blocks.getIterator(); i.atEnd() == false; i++) { MapBlock *block = i.getNode()->getValue(); modified_blocks.insert(block->getPos(), block); - - /* - Update water pressure. - This also adds suitable nodes to active_nodes. - */ - - MapVoxelManipulator v(&map); - - VoxelArea area(block->getPosRelative(), - block->getPosRelative() + v3s16(1,1,1)*(MAP_BLOCKSIZE-1)); - - try - { - v.updateAreaWaterPressure(area, m_server->m_flow_active_nodes); - } - catch(ProcessingLimitException &e) - { - dstream<<"Processing limit reached (1)"<getValue(); modified_blocks.insert(block->getPos(), block); } - } + } // envlock /* Set the modified blocks unsent for all the clients @@ -1492,7 +1489,7 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // Get material at position material = m_env.getMap().getNode(p_under).d; // If it's not diggable, do nothing - if(material_diggable(material) == false) + if(content_diggable(material) == false) { return; } @@ -1539,6 +1536,8 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // This also adds it to m_flow_active_nodes if appropriate MapVoxelManipulator v(&m_env.getMap()); + v.m_disable_water_climb = + g_settings.getBool("disable_water_climb"); VoxelArea area(p_under-v3s16(1,1,1), p_under+v3s16(1,1,1)); @@ -1575,15 +1574,10 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) */ if(std::string("MaterialItem") == item->getName()) { - MaterialItem *mitem = (MaterialItem*)item; - - MapNode n; - n.d = mitem->getMaterial(); - try{ // Don't add a node if this is not a free space MapNode n2 = m_env.getMap().getNode(p_over); - if(material_buildable_to(n2.d) == false) + if(content_buildable_to(n2.d) == false) return; } catch(InvalidPositionException &e) @@ -1596,17 +1590,14 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // Reset build time counter getClient(peer->id)->m_time_from_building.set(0.0); - if(g_settings.getBool("creative_mode") == false) - { - // Remove from inventory and send inventory - if(mitem->getCount() == 1) - player->inventory.deleteItem(item_i); - else - mitem->remove(1); - // Send inventory - SendInventory(peer_id); - } - + // Create node data + MaterialItem *mitem = (MaterialItem*)item; + MapNode n; + n.d = mitem->getMaterial(); + if(content_directional(n.d)) + n.dir = packDir(p_under - p_over); + +#if 1 // Create packet u32 replysize = 8 + MapNode::serializedLength(peer_ser_ver); SharedBuffer reply(replysize); @@ -1618,6 +1609,20 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // Send as reliable m_con.SendToAll(0, reply, true); + /* + Handle inventory + */ + if(g_settings.getBool("creative_mode") == false) + { + // Remove from inventory and send inventory + if(mitem->getCount() == 1) + player->inventory.deleteItem(item_i); + else + mitem->remove(1); + // Send inventory + SendInventory(peer_id); + } + /* Add node. @@ -1625,6 +1630,49 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) */ core::map modified_blocks; m_env.getMap().addNodeAndUpdate(p_over, n, modified_blocks); +#endif +#if 0 + /* + Handle inventory + */ + if(g_settings.getBool("creative_mode") == false) + { + // Remove from inventory and send inventory + if(mitem->getCount() == 1) + player->inventory.deleteItem(item_i); + else + mitem->remove(1); + // Send inventory + SendInventory(peer_id); + } + + /* + Add node. + + This takes some time so it is done after the quick stuff + */ + core::map modified_blocks; + m_env.getMap().addNodeAndUpdate(p_over, n, modified_blocks); + + /* + Set the modified blocks unsent for all the clients + */ + + //JMutexAutoLock lock2(m_con_mutex); + + for(core::map::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) + { + RemoteClient *client = i.getNode()->getValue(); + + if(modified_blocks.size() > 0) + { + // Remove block from sent history + client->SetBlocksNotSent(modified_blocks); + } + } +#endif /* Update water @@ -1634,6 +1682,8 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // This also adds it to m_flow_active_nodes if appropriate MapVoxelManipulator v(&m_env.getMap()); + v.m_disable_water_climb = + g_settings.getBool("disable_water_climb"); VoxelArea area(p_over-v3s16(1,1,1), p_over+v3s16(1,1,1)); @@ -1825,6 +1875,8 @@ void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver) writeS16(&reply[4], p.Y); writeS16(&reply[6], p.Z); memcpy(&reply[8], *blockdata, blockdata.getSize()); + + //dstream<<"Sending block: packet size: "< ps, u8 ver) -{ - DSTACK(__FUNCTION_NAME); - dstream<<"Server sending sector meta of " - <::Iterator i = ps.begin(); - core::list sendlist; - for(;;) - { - if(sendlist.size() == 255 || i == ps.end()) - { - if(sendlist.size() == 0) - break; - /* - [0] u16 command - [2] u8 sector count - [3...] v2s16 pos + sector metadata - */ - std::ostringstream os(std::ios_base::binary); - u8 buf[4]; - - writeU16(buf, TOCLIENT_SECTORMETA); - os.write((char*)buf, 2); - - writeU8(buf, sendlist.size()); - os.write((char*)buf, 1); - - for(core::list::Iterator - j = sendlist.begin(); - j != sendlist.end(); j++) - { - // Write position - writeV2S16(buf, *j); - os.write((char*)buf, 4); - - /* - Write ClientMapSector metadata - */ - - /* - [0] u8 serialization version - [1] s16 corners[0] - [3] s16 corners[1] - [5] s16 corners[2] - [7] s16 corners[3] - size = 9 - - In which corners are in these positions - v2s16(0,0), - v2s16(1,0), - v2s16(1,1), - v2s16(0,1), - */ - - // Write version - writeU8(buf, ver); - os.write((char*)buf, 1); - - // Write corners - // TODO: Get real values - s16 corners[4]; - ((ServerMap&)m_env.getMap()).getSectorCorners(*j, corners); - - writeS16(buf, corners[0]); - os.write((char*)buf, 2); - writeS16(buf, corners[1]); - os.write((char*)buf, 2); - writeS16(buf, corners[2]); - os.write((char*)buf, 2); - writeS16(buf, corners[3]); - os.write((char*)buf, 2); - } - - SharedBuffer data((u8*)os.str().c_str(), os.str().size()); - - /*dstream<<"Server::SendSectorMeta(): sending packet" - " with "< Server::getPlayerInfo() { DSTACK(__FUNCTION_NAME); @@ -2039,11 +1990,11 @@ void Server::peerAdded(con::Peer *peer) if(g_settings.getBool("creative_mode")) { // Give all materials - assert(USEFUL_MATERIAL_COUNT <= PLAYER_INVENTORY_SIZE); - for(u16 i=0; igetValue(); } +void Server::UpdateBlockWaterPressure(MapBlock *block, + core::map &modified_blocks) +{ + MapVoxelManipulator v(&m_env.getMap()); + v.m_disable_water_climb = + g_settings.getBool("disable_water_climb"); + + VoxelArea area(block->getPosRelative(), + block->getPosRelative() + v3s16(1,1,1)*(MAP_BLOCKSIZE-1)); + + try + { + v.updateAreaWaterPressure(area, m_flow_active_nodes); + } + catch(ProcessingLimitException &e) + { + dstream<<"Processing limit reached (1)"< &modified_blocks); // NOTE: If connection and environment are both to be locked, // environment shall be locked first. - JMutex m_env_mutex; Environment m_env; diff --git a/src/test.cpp b/src/test.cpp index 829aec8c1..726930ce6 100644 --- a/src/test.cpp +++ b/src/test.cpp @@ -133,11 +133,11 @@ struct TestMapNode MapNode n; // Default values - assert(n.d == MATERIAL_AIR); + assert(n.d == CONTENT_AIR); assert(n.getLight() == 0); // Transparency - n.d = MATERIAL_AIR; + n.d = CONTENT_AIR; assert(n.light_propagates() == true); n.d = 0; assert(n.light_propagates() == false); @@ -243,11 +243,11 @@ struct TestVoxelManipulator MapNode n; //n.pressure = size.Y - y; if(*p == '#') - n.d = MATERIAL_STONE; + n.d = CONTENT_STONE; else if(*p == '.') - n.d = MATERIAL_WATER; + n.d = CONTENT_WATER; else if(*p == ' ') - n.d = MATERIAL_AIR; + n.d = CONTENT_AIR; else assert(0); v.setNode(v3s16(x,y,z), n); @@ -262,8 +262,12 @@ struct TestVoxelManipulator v.print(dstream, VOXELPRINT_WATERPRESSURE); s16 highest_y = -32768; - assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == -1); - assert(highest_y == 3); + /* + NOTE: These are commented out because this behaviour is changed + all the time + */ + //assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == -1); + //assert(highest_y == 3); /*assert(v.getWaterPressure(v3s16(7, 1, 1), highest_y, 0) == 3); //assert(highest_y == 3);*/ @@ -365,11 +369,11 @@ struct TestMapBlock assert(b.getChangedFlag() == false); // All nodes should have been set to - // .d=MATERIAL_AIR and .getLight() = 0 + // .d=CONTENT_AIR and .getLight() = 0 for(u16 z=0; z light_sources; // The bottom block is invalid, because we have a shadowing node @@ -493,7 +497,7 @@ struct TestMapBlock for(u16 y=0; y #include #include +#include +#include extern const v3s16 g_26dirs[26]; @@ -808,5 +810,45 @@ private: core::map m_settings; }; +/* + A thread-safe texture cache. + + This is used so that irrlicht doesn't get called from many threads +*/ + +class TextureCache +{ +public: + TextureCache() + { + m_mutex.Init(); + assert(m_mutex.IsInitialized()); + } + + void set(std::string name, video::ITexture *texture) + { + JMutexAutoLock lock(m_mutex); + + m_textures[name] = texture; + } + + video::ITexture* get(std::string name) + { + JMutexAutoLock lock(m_mutex); + + core::map::Node *n; + n = m_textures.find(name); + + if(n != NULL) + return n->getValue(); + + return NULL; + } + +private: + core::map m_textures; + JMutex m_mutex; +}; + #endif diff --git a/src/voxel.cpp b/src/voxel.cpp index cdd41a14f..3df29dc68 100644 --- a/src/voxel.cpp +++ b/src/voxel.cpp @@ -41,6 +41,7 @@ VoxelManipulator::VoxelManipulator(): m_data(NULL), m_flags(NULL) { + m_disable_water_climb = false; } VoxelManipulator::~VoxelManipulator() @@ -103,13 +104,13 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode) } else if(mode == VOXELPRINT_WATERPRESSURE) { - if(m == MATERIAL_WATER) + if(m == CONTENT_WATER) { c = 'w'; if(pr <= 9) c = pr + '0'; } - else if(m == MATERIAL_AIR) + else if(liquid_replaces_content(m)) { c = ' '; } @@ -249,7 +250,7 @@ void VoxelManipulator::interpolate(VoxelArea area) s16 total = 0; s16 airness = 0; - u8 m = MATERIAL_IGNORE; + u8 m = CONTENT_IGNORE; for(s16 i=0; i<8; i++) //for(s16 i=0; i<26; i++) @@ -263,17 +264,17 @@ void VoxelManipulator::interpolate(VoxelArea area) MapNode &n = m_data[m_area.index(p2)]; - airness += (n.d == MATERIAL_AIR) ? 1 : -1; + airness += (n.d == CONTENT_AIR) ? 1 : -1; total++; - if(m == MATERIAL_IGNORE && n.d != MATERIAL_AIR) + if(m == CONTENT_IGNORE && n.d != CONTENT_AIR) m = n.d; } // 1 if air, 0 if not - buf[area.index(p)] = airness > -total/2 ? MATERIAL_AIR : m; - //buf[area.index(p)] = airness > -total ? MATERIAL_AIR : m; - //buf[area.index(p)] = airness >= -7 ? MATERIAL_AIR : m; + buf[area.index(p)] = airness > -total/2 ? CONTENT_AIR : m; + //buf[area.index(p)] = airness > -total ? CONTENT_AIR : m; + //buf[area.index(p)] = airness >= -7 ? CONTENT_AIR : m; } for(s32 z=area.MinEdge.Z; z<=area.MaxEdge.Z; z++) @@ -366,13 +367,14 @@ int VoxelManipulator::getWaterPressure(v3s16 p, s16 &highest_y, int recur_count) continue; MapNode &n = m_data[m_area.index(p2)]; // Ignore non-liquid nodes - if(material_liquid(n.d) == false) + if(content_liquid(n.d) == false) continue; int pr; // If at ocean surface - if(n.pressure == 1 && n.d == MATERIAL_OCEAN) + if(n.pressure == 1 && n.d == CONTENT_OCEAN) + //if(n.pressure == 1) // Causes glitches but is fast { pr = 1; } @@ -463,12 +465,15 @@ void VoxelManipulator::spreadWaterPressure(v3s16 p, int pr, NOTE: Do not remove anything from there. We cannot know here if some other neighbor of it causes flow. */ - if(n.d == MATERIAL_AIR) + if(liquid_replaces_content(n.d)) { bool pressure_causes_flow = false; - // If block is at top + // If empty block is at top if(i == 0) { + if(m_disable_water_climb) + continue; + //if(pr >= PRESERVE_WATER_VOLUME ? 3 : 2) if(pr >= 3) pressure_causes_flow = true; @@ -495,7 +500,7 @@ void VoxelManipulator::spreadWaterPressure(v3s16 p, int pr, } // Ignore non-liquid nodes - if(material_liquid(n.d) == false) + if(content_liquid(n.d) == false) continue; int pr2 = pr; @@ -511,6 +516,12 @@ void VoxelManipulator::spreadWaterPressure(v3s16 p, int pr, if(pr2 < 255) pr2++; } + + /*if(m_disable_water_climb) + { + if(pr2 > 3) + pr2 = 3; + }*/ // Ignore if correct pressure is already set and is not on // request_area. @@ -556,7 +567,7 @@ void VoxelManipulator::updateAreaWaterPressure(VoxelArea a, continue; MapNode &n = m_data[m_area.index(p)]; // Ignore non-liquid nodes - if(material_liquid(n.d) == false) + if(content_liquid(n.d) == false) continue; if(checked2_clear == false) @@ -654,14 +665,18 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos, if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED)) return false; MapNode &n = m_data[m_area.index(removed_pos)]; - // Water can move only to air - if(n.d != MATERIAL_AIR) + // Ignore nodes to which the water can't go + if(liquid_replaces_content(n.d) == false) return false; } s32 i; for(i=0; i<6; i++) { + // Don't raise water from bottom + if(m_disable_water_climb && i == 5) + continue; + p = removed_pos + v3s16(s1*dirs[i].X, dirs[i].Y, s2*dirs[i].Z); u8 f = m_flags[m_area.index(p)]; @@ -670,7 +685,7 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos, continue; MapNode &n = m_data[m_area.index(p)]; // Only liquid nodes can move - if(material_liquid(n.d) == false) + if(content_liquid(n.d) == false) continue; // If block is at top, select it always if(i == 0) @@ -704,7 +719,7 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos, u8 m = m_data[m_area.index(p)].d; u8 f = m_flags[m_area.index(p)]; - if(m == MATERIAL_OCEAN) + if(m == CONTENT_OCEAN) from_ocean = true; // Move air bubble if not taking water from ocean @@ -714,9 +729,23 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos, m_flags[m_area.index(p)] = m_flags[m_area.index(removed_pos)]; } + /* + This has to be done to copy the brightness of a light source + correctly. Otherwise unspreadLight will fuck up when water + has replaced a light source. + */ + u8 light = m_data[m_area.index(removed_pos)].getLight(); + m_data[m_area.index(removed_pos)].d = m; m_flags[m_area.index(removed_pos)] = f; + m_data[m_area.index(removed_pos)].setLight(light); + + /*// NOTE: HACK: This has to be set to LIGHT_MAX so that + // unspreadLight will clear all light that came from this node. + // Otherwise there will be weird bugs + m_data[m_area.index(removed_pos)].setLight(LIGHT_MAX);*/ + // Mark removed_pos checked m_flags[m_area.index(removed_pos)] |= VOXELFLAG_CHECKED; @@ -728,7 +757,7 @@ bool VoxelManipulator::flowWater(v3s16 removed_pos, /* NOTE: This does not work as-is - if(m == MATERIAL_OCEAN) + if(m == CONTENT_OCEAN) { // If block was raised to surface, increase pressure of // source node @@ -795,6 +824,10 @@ find_again: // They are checked in reverse order compared to the previous loop. for(s32 i=5; i>=0; i--) { + // Don't try to flow to top + if(m_disable_water_climb && i == 0) + continue; + //v3s16 p = removed_pos + dirs[i]; p = removed_pos + v3s16(s1*dirs[i].X, dirs[i].Y, s2*dirs[i].Z); @@ -804,7 +837,7 @@ find_again: continue; MapNode &n = m_data[m_area.index(p)]; // Water can only move to air - if(n.d != MATERIAL_AIR) + if(liquid_replaces_content(n.d) == false) continue; // Flow water to node diff --git a/src/voxel.h b/src/voxel.h index 411cf4376..472f0740d 100644 --- a/src/voxel.h +++ b/src/voxel.h @@ -502,6 +502,12 @@ public: //TODO: Would these make any speed improvement? //bool m_pressure_route_valid; //v3s16 m_pressure_route_surface; + + /* + Some settings + */ + bool m_disable_water_climb; + private: }; -- cgit v1.2.3