From 682c9d8e7d05ca7462eda7fee9b07fb6ad94d860 Mon Sep 17 00:00:00 2001 From: Perttu Ahola Date: Fri, 17 Jun 2011 23:20:31 +0300 Subject: Moved stuff from mapblock{h,cpp} to mapblock_mesh.{h,cpp} and content_mapblock.{h,cpp} --- src/mapblock_mesh.cpp | 789 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 789 insertions(+) create mode 100644 src/mapblock_mesh.cpp (limited to 'src/mapblock_mesh.cpp') diff --git a/src/mapblock_mesh.cpp b/src/mapblock_mesh.cpp new file mode 100644 index 000000000..a8624e8f3 --- /dev/null +++ b/src/mapblock_mesh.cpp @@ -0,0 +1,789 @@ +/* +Minetest-c55 +Copyright (C) 2010-2011 celeron55, Perttu Ahola + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#include "mapblock_mesh.h" +#include "light.h" +#include "mapblock.h" +#include "map.h" +#include "main.h" // For g_settings and g_texturesource +#include "content_mapblock.h" + +void MeshMakeData::fill(u32 daynight_ratio, MapBlock *block) +{ + m_daynight_ratio = daynight_ratio; + m_blockpos = block->getPos(); + + v3s16 blockpos_nodes = m_blockpos*MAP_BLOCKSIZE; + + /* + There is no harm not copying the TempMods of the neighbors + because they are already copied to this block + */ + m_temp_mods.clear(); + block->copyTempMods(m_temp_mods); + + /* + Copy data + */ + + // 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))); + + { + //TimeTaker timer("copy central block data"); + // 0ms + + // Copy our data + block->copyTo(m_vmanip); + } + { + //TimeTaker timer("copy neighbor block data"); + // 0ms + + /* + Copy neighbors. This is lightning fast. + Copying only the borders would be *very* slow. + */ + + // Get map + NodeContainer *parentcontainer = block->getParent(); + // This will only work if the parent is the map + assert(parentcontainer->nodeContainerId() == NODECONTAINER_ID_MAP); + // OK, we have the map! + Map *map = (Map*)parentcontainer; + + for(u16 i=0; i<6; i++) + { + const v3s16 &dir = g_6dirs[i]; + v3s16 bp = m_blockpos + dir; + MapBlock *b = map->getBlockNoCreateNoEx(bp); + if(b) + b->copyTo(m_vmanip); + } + } +} + +/* + vertex_dirs: v3s16[4] +*/ +void getNodeVertexDirs(v3s16 dir, v3s16 *vertex_dirs) +{ + /* + If looked from outside the node towards the face, the corners are: + 0: bottom-right + 1: bottom-left + 2: top-left + 3: top-right + */ + if(dir == v3s16(0,0,1)) + { + // If looking towards z+, this is the face that is behind + // the center point, facing towards z+. + vertex_dirs[0] = v3s16(-1,-1, 1); + vertex_dirs[1] = v3s16( 1,-1, 1); + vertex_dirs[2] = v3s16( 1, 1, 1); + vertex_dirs[3] = v3s16(-1, 1, 1); + } + else if(dir == v3s16(0,0,-1)) + { + // faces towards Z- + vertex_dirs[0] = v3s16( 1,-1,-1); + vertex_dirs[1] = v3s16(-1,-1,-1); + vertex_dirs[2] = v3s16(-1, 1,-1); + vertex_dirs[3] = v3s16( 1, 1,-1); + } + else if(dir == v3s16(1,0,0)) + { + // faces towards X+ + vertex_dirs[0] = v3s16( 1,-1, 1); + vertex_dirs[1] = v3s16( 1,-1,-1); + vertex_dirs[2] = v3s16( 1, 1,-1); + vertex_dirs[3] = v3s16( 1, 1, 1); + } + else if(dir == v3s16(-1,0,0)) + { + // faces towards X- + vertex_dirs[0] = v3s16(-1,-1,-1); + vertex_dirs[1] = v3s16(-1,-1, 1); + vertex_dirs[2] = v3s16(-1, 1, 1); + vertex_dirs[3] = v3s16(-1, 1,-1); + } + else if(dir == v3s16(0,1,0)) + { + // faces towards Y+ (assume Z- as "down" in texture) + vertex_dirs[0] = v3s16( 1, 1,-1); + vertex_dirs[1] = v3s16(-1, 1,-1); + vertex_dirs[2] = v3s16(-1, 1, 1); + vertex_dirs[3] = v3s16( 1, 1, 1); + } + else if(dir == v3s16(0,-1,0)) + { + // faces towards Y- (assume Z+ as "down" in texture) + vertex_dirs[0] = v3s16( 1,-1, 1); + vertex_dirs[1] = v3s16(-1,-1, 1); + vertex_dirs[2] = v3s16(-1,-1,-1); + vertex_dirs[3] = v3s16( 1,-1,-1); + } +} + +inline video::SColor lightColor(u8 alpha, u8 light) +{ + return video::SColor(alpha,light,light,light); +} + +struct FastFace +{ + TileSpec tile; + video::S3DVertex vertices[4]; // Precalculated vertices +}; + +void makeFastFace(TileSpec tile, u8 li0, u8 li1, u8 li2, u8 li3, v3f p, + v3s16 dir, v3f scale, v3f posRelative_f, + core::array &dest) +{ + FastFace face; + + // Position is at the center of the cube. + v3f pos = p * BS; + posRelative_f *= BS; + + v3f vertex_pos[4]; + v3s16 vertex_dirs[4]; + getNodeVertexDirs(dir, vertex_dirs); + for(u16 i=0; i<4; i++) + { + vertex_pos[i] = v3f( + BS/2*vertex_dirs[i].X, + BS/2*vertex_dirs[i].Y, + BS/2*vertex_dirs[i].Z + ); + } + + 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 alpha = tile.alpha; + /*u8 alpha = 255; + if(tile.id == TILE_WATER) + alpha = WATER_ALPHA;*/ + + float x0 = tile.texture.pos.X; + float y0 = tile.texture.pos.Y; + float w = tile.texture.size.X; + float h = tile.texture.size.Y; + + /*video::SColor c = lightColor(alpha, li); + + face.vertices[0] = video::S3DVertex(vertex_pos[0], v3f(0,1,0), c, + core::vector2d(x0+w*abs_scale, y0+h)); + face.vertices[1] = video::S3DVertex(vertex_pos[1], v3f(0,1,0), c, + core::vector2d(x0, y0+h)); + face.vertices[2] = video::S3DVertex(vertex_pos[2], v3f(0,1,0), c, + core::vector2d(x0, y0)); + face.vertices[3] = video::S3DVertex(vertex_pos[3], v3f(0,1,0), c, + core::vector2d(x0+w*abs_scale, y0));*/ + + face.vertices[0] = video::S3DVertex(vertex_pos[0], v3f(0,1,0), + lightColor(alpha, li0), + core::vector2d(x0+w*abs_scale, y0+h)); + face.vertices[1] = video::S3DVertex(vertex_pos[1], v3f(0,1,0), + lightColor(alpha, li1), + core::vector2d(x0, y0+h)); + face.vertices[2] = video::S3DVertex(vertex_pos[2], v3f(0,1,0), + lightColor(alpha, li2), + core::vector2d(x0, y0)); + face.vertices[3] = video::S3DVertex(vertex_pos[3], v3f(0,1,0), + lightColor(alpha, li3), + core::vector2d(x0+w*abs_scale, y0)); + + face.tile = tile; + //DEBUG + //f->tile = TILE_STONE; + + dest.push_back(face); +} + +/* + Gets node tile from any place relative to block. + Returns TILE_NODE if doesn't exist or should not be drawn. +*/ +TileSpec getNodeTile(MapNode mn, v3s16 p, v3s16 face_dir, + NodeModMap &temp_mods) +{ + TileSpec spec; + spec = mn.getTile(face_dir); + + /* + Check temporary modifications on this node + */ + /*core::map::Node *n; + n = m_temp_mods.find(p); + // If modified + if(n != NULL) + { + struct NodeMod mod = n->getValue();*/ + NodeMod mod; + if(temp_mods.get(p, &mod)) + { + if(mod.type == NODEMOD_CHANGECONTENT) + { + MapNode mn2(mod.param); + spec = mn2.getTile(face_dir); + } + if(mod.type == NODEMOD_CRACK) + { + /* + Get texture id, translate it to name, append stuff to + name, get texture id + */ + + // Get original texture name + u32 orig_id = spec.texture.id; + std::string orig_name = g_texturesource->getTextureName(orig_id); + + // Create new texture name + std::ostringstream os; + os<getTextureId(os.str()); + + /*dstream<<"MapBlock::getNodeTile(): Switching from " + <getTexture(new_id); + } + } + + return spec; +} + +u8 getNodeContent(v3s16 p, MapNode mn, NodeModMap &temp_mods) +{ + /* + Check temporary modifications on this node + */ + /*core::map::Node *n; + n = m_temp_mods.find(p); + // If modified + if(n != NULL) + { + struct NodeMod mod = n->getValue();*/ + NodeMod mod; + if(temp_mods.get(p, &mod)) + { + 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; +} + +v3s16 dirs8[8] = { + v3s16(0,0,0), + v3s16(0,0,1), + v3s16(0,1,0), + v3s16(0,1,1), + v3s16(1,0,0), + v3s16(1,1,0), + v3s16(1,0,1), + v3s16(1,1,1), +}; + +// Calculate lighting at the XYZ- corner of p +u8 getSmoothLight(v3s16 p, VoxelManipulator &vmanip, u32 daynight_ratio) +{ + u16 ambient_occlusion = 0; + u16 light = 0; + u16 light_count = 0; + for(u32 i=0; i<8; i++) + { + MapNode n = vmanip.getNodeNoEx(p - dirs8[i]); + if(content_features(n.d).param_type == CPT_LIGHT) + { + light += decode_light(n.getLightBlend(daynight_ratio)); + light_count++; + } + else + { + if(n.d != CONTENT_IGNORE) + ambient_occlusion++; + } + } + + if(light_count == 0) + return 255; + + light /= light_count; + + if(ambient_occlusion > 4) + { + ambient_occlusion -= 4; + light = (float)light / ((float)ambient_occlusion * 0.5 + 1.0); + } + + return light; +} + +// Calculate lighting at the given corner of p +u8 getSmoothLight(v3s16 p, v3s16 corner, + VoxelManipulator &vmanip, u32 daynight_ratio) +{ + if(corner.X == 1) p.X += 1; + else assert(corner.X == -1); + if(corner.Y == 1) p.Y += 1; + else assert(corner.Y == -1); + if(corner.Z == 1) p.Z += 1; + else assert(corner.Z == -1); + + return getSmoothLight(p, vmanip, daynight_ratio); +} + +void getTileInfo( + // Input: + v3s16 blockpos_nodes, + v3s16 p, + v3s16 face_dir, + u32 daynight_ratio, + VoxelManipulator &vmanip, + NodeModMap &temp_mods, + bool smooth_lighting, + // Output: + bool &makes_face, + v3s16 &p_corrected, + v3s16 &face_dir_corrected, + u8 *lights, + TileSpec &tile + ) +{ + MapNode n0 = vmanip.getNodeNoEx(blockpos_nodes + p); + MapNode n1 = vmanip.getNodeNoEx(blockpos_nodes + p + face_dir); + TileSpec tile0 = getNodeTile(n0, p, face_dir, temp_mods); + TileSpec tile1 = getNodeTile(n1, p + face_dir, -face_dir, temp_mods); + + // This is hackish + u8 content0 = getNodeContent(p, n0, temp_mods); + u8 content1 = getNodeContent(p + face_dir, n1, temp_mods); + u8 mf = face_contents(content0, content1); + + if(mf == 0) + { + makes_face = false; + return; + } + + makes_face = true; + + if(mf == 1) + { + tile = tile0; + p_corrected = p; + face_dir_corrected = face_dir; + } + else + { + tile = tile1; + p_corrected = p + face_dir; + face_dir_corrected = -face_dir; + } + + if(smooth_lighting == false) + { + lights[0] = lights[1] = lights[2] = lights[3] = + decode_light(getFaceLight(daynight_ratio, n0, n1, face_dir)); + } + else + { + v3s16 vertex_dirs[4]; + getNodeVertexDirs(face_dir_corrected, vertex_dirs); + for(u16 i=0; i<4; i++) + { + lights[i] = getSmoothLight(blockpos_nodes + p_corrected, + vertex_dirs[i], vmanip, daynight_ratio); + } + } + + return; +} + +/* + 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 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 &dest, + NodeModMap &temp_mods, + VoxelManipulator &vmanip, + v3s16 blockpos_nodes, + bool smooth_lighting) +{ + v3s16 p = startpos; + + u16 continuous_tiles_count = 0; + + bool makes_face; + v3s16 p_corrected; + v3s16 face_dir_corrected; + u8 lights[4]; + TileSpec tile; + getTileInfo(blockpos_nodes, p, face_dir, daynight_ratio, + vmanip, temp_mods, smooth_lighting, + makes_face, p_corrected, face_dir_corrected, lights, tile); + + for(u16 j=0; j fastfaces_new; + + v3s16 blockpos_nodes = data->m_blockpos*MAP_BLOCKSIZE; + + // floating point conversion + v3f posRelative_f(blockpos_nodes.X, blockpos_nodes.Y, blockpos_nodes.Z); + + /* + Some settings + */ + //bool new_style_water = g_settings.getBool("new_style_water"); + //bool new_style_leaves = g_settings.getBool("new_style_leaves"); + bool smooth_lighting = g_settings.getBool("smooth_lighting"); + + /* + 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. + */ + + { + // 4-23ms for MAP_BLOCKSIZE=16 + //TimeTaker timer2("updateMesh() collect"); + + /* + Go through every y,z and get top(y+) faces in rows of x+ + */ + for(s16 y=0; ym_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, + data->m_temp_mods, + data->m_vmanip, + blockpos_nodes, + smooth_lighting); + } + } + /* + Go through every x,y and get right(x+) faces in rows of z+ + */ + for(s16 x=0; xm_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, + data->m_temp_mods, + data->m_vmanip, + blockpos_nodes, + smooth_lighting); + } + } + /* + Go through every y,z and get back(z+) faces in rows of x+ + */ + for(s16 z=0; zm_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, + data->m_temp_mods, + data->m_vmanip, + blockpos_nodes, + smooth_lighting); + } + } + } + + // End of slow part + + /* + Convert FastFaces to SMesh + */ + + MeshCollector collector; + + if(fastfaces_new.size() > 0) + { + // avg 0ms (100ms spikes when loading textures the first time) + //TimeTaker timer2("updateMesh() mesh building"); + + video::SMaterial material; + material.setFlag(video::EMF_LIGHTING, false); + 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); + + for(u32 i=0; irecalculateBoundingBox(); + + /* + Delete new mesh if it is empty + */ + + if(mesh_new->getMeshBufferCount() == 0) + { + mesh_new->drop(); + mesh_new = NULL; + } + + if(mesh_new) + { +#if 0 + // Usually 1-700 faces and 1-7 materials + std::cout<<"Updated MapBlock has "<getMeshBufferCount() + <<" materials (meshbuffers)"<setHardwareMappingHint(scene::EHM_STATIC); + + /* + NOTE: If that is enabled, some kind of a queue to the main + thread should be made which would call irrlicht to delete + the hardware buffer and then delete the mesh + */ + } + + return mesh_new; + + //std::cout<<"added "< Date: Sat, 25 Jun 2011 16:32:09 +0300 Subject: mapgen stuff --- src/defaultsettings.cpp | 1 + src/environment.cpp | 2 + src/map.cpp | 535 ++++++++++++++++++++++++++++++------------------ src/mapblock_mesh.cpp | 4 +- src/noise.h | 39 ++++ src/server.cpp | 2 +- src/utility.h | 5 + 7 files changed, 392 insertions(+), 196 deletions(-) (limited to 'src/mapblock_mesh.cpp') diff --git a/src/defaultsettings.cpp b/src/defaultsettings.cpp index 289be0a06..74d323237 100644 --- a/src/defaultsettings.cpp +++ b/src/defaultsettings.cpp @@ -92,5 +92,6 @@ void set_default_settings() g_settings.setDefault("server_unload_unused_sectors_timeout", "60"); g_settings.setDefault("server_map_save_interval", "60"); g_settings.setDefault("full_block_send_enable_min_time_from_building", "2.0"); + //g_settings.setDefault("dungeon_rarity", "0.025"); } diff --git a/src/environment.cpp b/src/environment.cpp index 9bbba08b0..cd255341f 100644 --- a/src/environment.cpp +++ b/src/environment.cpp @@ -619,6 +619,7 @@ void ServerEnvironment::activateBlock(MapBlock *block, u32 additional_dtime) { v3s16 p = p0 + block->getPosRelative(); MapNode n = block->getNodeNoEx(p0); +#if 1 // Test something: // Convert all mud under proper day lighting to grass if(n.d == CONTENT_MUD) @@ -634,6 +635,7 @@ void ServerEnvironment::activateBlock(MapBlock *block, u32 additional_dtime) } } } +#endif } } diff --git a/src/map.cpp b/src/map.cpp index fe6b7a701..cb0967c35 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -2169,6 +2169,7 @@ void make_randomstone(VoxelManipulator &vmanip, v3s16 p0) } #endif +#if 0 void make_largestone(VoxelManipulator &vmanip, v3s16 p0) { MapNode stonenode(CONTENT_STONE); @@ -2250,6 +2251,7 @@ void make_largestone(VoxelManipulator &vmanip, v3s16 p0) vmanip.m_data[vi] = stonenode; } } +#endif /* Dungeon making routines @@ -2375,39 +2377,79 @@ void make_hole1(VoxelManipulator &vmanip, v3s16 place) void make_door1(VoxelManipulator &vmanip, v3s16 doorplace, v3s16 doordir) { make_hole1(vmanip, doorplace); + // Place torch (for testing) + //vmanip.m_data[vmanip.m_area.index(doorplace)] = MapNode(CONTENT_TORCH); +} + +v3s16 rand_ortho_dir(PseudoRandom &random) +{ + if(random.next()%2==0) + return random.next()%2 ? v3s16(-1,0,0) : v3s16(1,0,0); + else + return random.next()%2 ? v3s16(0,0,-1) : v3s16(0,0,1); } -v3s16 rand_ortho_dir() +v3s16 turn_xz(v3s16 olddir, int t) { - if(myrand()%2==0) - return myrand()%2 ? v3s16(-1,0,0) : v3s16(1,0,0); + v3s16 dir; + if(t == 0) + { + // Turn right + dir.X = olddir.Z; + dir.Z = -olddir.X; + dir.Y = olddir.Y; + } else - return myrand()%2 ? v3s16(0,0,-1) : v3s16(0,0,1); + { + // Turn left + dir.X = -olddir.Z; + dir.Z = olddir.X; + dir.Y = olddir.Y; + } + return dir; +} + +v3s16 random_turn(PseudoRandom &random, v3s16 olddir) +{ + int turn = random.range(0,2); + v3s16 dir; + if(turn == 0) + { + // Go straight + dir = olddir; + } + else if(turn == 1) + // Turn right + dir = turn_xz(olddir, 0); + else + // Turn left + dir = turn_xz(olddir, 1); + return dir; } void make_corridor(VoxelManipulator &vmanip, v3s16 doorplace, v3s16 doordir, - v3s16 &result_place, v3s16 &result_dir) + v3s16 &result_place, v3s16 &result_dir, PseudoRandom &random) { make_hole1(vmanip, doorplace); v3s16 p0 = doorplace; v3s16 dir = doordir; u32 length; - if(myrand()%2) - length = myrand_range(1,13); + if(random.next()%2) + length = random.range(1,13); else - length = myrand_range(1,6); - u32 partlength = myrand_range(1,length); + length = random.range(1,6); + length = random.range(1,13); + u32 partlength = random.range(1,length); u32 partcount = 0; s16 make_stairs = 0; - if(myrand()%2 == 0 && partlength >= 3) - make_stairs = myrand()%2 ? 1 : -1; + if(random.next()%2 == 0 && partlength >= 3) + make_stairs = random.next()%2 ? 1 : -1; for(u32 i=0; i= partlength) { partcount = 0; - v3s16 newdir = rand_ortho_dir(); - partlength = myrand_range(1,7); - make_stairs = 0; - if(myrand()%2 == 0 && partlength >= 3) - make_stairs = myrand()%2 ? 1 : -1; + dir = random_turn(random, dir); + + partlength = random.range(1,length); - if(make_stairs != 0) - { - if(newdir.X == 0 && dir.X != 0) - dir = newdir; - if(newdir.Z == 0 && dir.Z != 0) - dir = newdir; - } - else - { - dir = newdir; - } - dir.Y = make_stairs; + make_stairs = 0; + if(random.next()%2 == 0 && partlength >= 3) + make_stairs = random.next()%2 ? 1 : -1; } } - //p0.Y -= make_stairs; - dir.Y = 0; result_place = p0; result_dir = dir; } @@ -2466,16 +2513,17 @@ class RoomWalker { public: - RoomWalker(VoxelManipulator &vmanip_, v3s16 pos): + RoomWalker(VoxelManipulator &vmanip_, v3s16 pos, PseudoRandom &random): vmanip(vmanip_), - m_pos(pos) + m_pos(pos), + m_random(random) { randomizeDir(); } void randomizeDir() { - m_dir = rand_ortho_dir(); + m_dir = rand_ortho_dir(m_random); } void setPos(v3s16 pos) @@ -2561,13 +2609,13 @@ public: v3s16 roomplace; // X east, Z north, Y up if(doordir == v3s16(1,0,0)) // X+ - roomplace = doorplace + v3s16(0,-1,-roomsize.Z/2+myrand_range(-roomsize.Z/2,roomsize.Z/2)); + roomplace = doorplace + v3s16(0,-1,-roomsize.Z/2+m_random.range(-roomsize.Z/2+1,roomsize.Z/2-1)); if(doordir == v3s16(-1,0,0)) // X- - roomplace = doorplace + v3s16(-roomsize.X+1,-1,-roomsize.Z/2+myrand_range(-roomsize.Z/2,roomsize.Z/2)); + roomplace = doorplace + v3s16(-roomsize.X+1,-1,-roomsize.Z/2+m_random.range(-roomsize.Z/2+1,roomsize.Z/2-1)); if(doordir == v3s16(0,0,1)) // Z+ - roomplace = doorplace + v3s16(-roomsize.X/2+myrand_range(-roomsize.X/2,roomsize.X/2),-1,0); + roomplace = doorplace + v3s16(-roomsize.X/2+m_random.range(-roomsize.X/2+1,roomsize.X/2-1),-1,0); if(doordir == v3s16(0,0,-1)) // Z- - roomplace = doorplace + v3s16(-roomsize.X/2+myrand_range(-roomsize.X/2,roomsize.X/2),-1,-roomsize.Z+1); + roomplace = doorplace + v3s16(-roomsize.X/2+m_random.range(-roomsize.X/2+1,roomsize.X/2-1),-1,-roomsize.Z+1); // Check fit bool fits = true; @@ -2604,58 +2652,133 @@ public: private: VoxelManipulator &vmanip; v3s16 m_pos; - v3s16 m_dir; + v3s16 m_dir; + PseudoRandom &m_random; }; -void make_dungeon1(VoxelManipulator &vmanip) +void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random) { v3s16 areasize = vmanip.m_area.getExtent(); v3s16 roomsize; v3s16 roomplace; - roomsize = v3s16(myrand_range(4,8),myrand_range(4,6),myrand_range(4,8)); - roomplace = vmanip.m_area.MinEdge + v3s16( - myrand_range(0,areasize.X-roomsize.X-1), - myrand_range(0,areasize.Y-roomsize.Y-1), - myrand_range(0,areasize.Z-roomsize.Z-1)); + /* + Find place for first room + */ + bool fits = false; + for(u32 i=0; i<100; i++) + { + roomsize = v3s16(random.range(4,8),random.range(4,6),random.range(4,8)); + roomplace = vmanip.m_area.MinEdge + v3s16( + random.range(0,areasize.X-roomsize.X-1), + random.range(0,areasize.Y-roomsize.Y-1), + random.range(0,areasize.Z-roomsize.Z-1)); + /* + Check that we're not putting the room to an unknown place, + otherwise it might end up floating in the air + */ + fits = true; + for(s16 z=1; zm_static_objects.insert(0, s_obj); delete obj; } - if(myrand() % 300 == 0) + if(myrand() % 1000 == 0) { v3f pos_f = intToFloat(p+block->getPosRelative(), BS); pos_f.Y -= BS*0.4; @@ -3078,18 +3202,18 @@ void makeBlock(BlockMakeData *data) s16 approx_ground_depth = approx_groundlevel - (node_min.Y+MAP_BLOCKSIZE/2); - /*s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level( + s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level( data->seed, v2s16(blockpos.X, blockpos.Z)); - // Minimum amount of ground above the central block - s16 minimum_ground_depth = minimum_groundlevel - node_max.Y;*/ - + // Minimum amount of ground above the top of the central block + s16 minimum_ground_depth = minimum_groundlevel - node_max.Y; + s16 maximum_groundlevel = (s16)get_sector_maximum_ground_level( data->seed, v2s16(blockpos.X, blockpos.Z), 1); - // Minimum amount of ground above the central block + // Maximum amount of ground above the bottom of the central block s16 maximum_ground_depth = maximum_groundlevel - node_min.Y; /* - Special case for high air or water + Special case for high air or water: Just fill with air and water. */ if(maximum_ground_depth < -20) { @@ -3121,6 +3245,18 @@ void makeBlock(BlockMakeData *data) // We're done return; } + + /* + If block is deep underground, this is set to true and ground + density noise is not generated, for speed optimization. + */ + bool all_is_ground_except_caves = (minimum_ground_depth > 16); + + /* + Create a block-specific seed + */ + u32 blockseed = (data->seed%0x100000000) + full_node_min.Z*38134234 + + full_node_min.Y*42123 + full_node_min.X*23; /* Make some 3D noise @@ -3145,8 +3281,7 @@ void makeBlock(BlockMakeData *data) noisebuf_cave.create(get_cave_noise1_params(data->seed), minpos_f.X, minpos_f.Y, minpos_f.Z, maxpos_f.X, maxpos_f.Y, maxpos_f.Z, - 4, 4, 4); - //3.5, 3.5, 3.5); + 4, 3, 4); noisebuf_cave.multiply(get_cave_noise2_params(data->seed)); @@ -3158,16 +3293,17 @@ void makeBlock(BlockMakeData *data) v3f sl = v3f(4.0, 4.0, 4.0); /* - Density + Density noise */ - //noisebuf_ground.create(data->seed+983240, 6, 0.60, false, - noisebuf_ground.create(get_ground_noise1_params(data->seed), - minpos_f.X, minpos_f.Y, minpos_f.Z, - maxpos_f.X, maxpos_f.Y, maxpos_f.Z, - sl.X, sl.Y, sl.Z); + if(all_is_ground_except_caves == false) + //noisebuf_ground.create(data->seed+983240, 6, 0.60, false, + noisebuf_ground.create(get_ground_noise1_params(data->seed), + minpos_f.X, minpos_f.Y, minpos_f.Z, + maxpos_f.X, maxpos_f.Y, maxpos_f.Z, + sl.X, sl.Y, sl.Z); /* - Content + Ground property noise */ sl = v3f(2.5, 2.5, 2.5); noisebuf_ground_crumbleness.create( @@ -3200,42 +3336,22 @@ void makeBlock(BlockMakeData *data) // Only modify places that have no content if(vmanip.m_data[i].d == CONTENT_IGNORE) { - if(noisebuf_cave.get(x,y,z) > CAVE_NOISE_THRESHOLD) + // First priority: make air and water. + // This avoids caves inside water. + if(all_is_ground_except_caves == false + && val_is_ground(noisebuf_ground.get(x,y,z), + v3s16(x,y,z), data->seed) == false) + { + if(y <= WATER_LEVEL) + vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE); + else + vmanip.m_data[i] = MapNode(CONTENT_AIR); + } + else if(noisebuf_cave.get(x,y,z) > CAVE_NOISE_THRESHOLD) vmanip.m_data[i] = MapNode(CONTENT_AIR); - else if(val_is_ground(noisebuf_ground.get(x,y,z), - v3s16(x,y,z), data->seed)) - vmanip.m_data[i] = MapNode(CONTENT_STONE); - else if(y <= WATER_LEVEL) - vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE); else - vmanip.m_data[i] = MapNode(CONTENT_AIR); - } - - /*if(noisebuf_cave.get(x,y,z) > CAVE_NOISE_THRESHOLD) - { - // Only modify places that have no content - if(vmanip.m_data[i].d == CONTENT_IGNORE) - vmanip.m_data[i] = MapNode(CONTENT_AIR); - } - else if(is_ground(noisebuf_ground.get(x,y,z), y)) - { - // Only modify places that have no content - if(vmanip.m_data[i].d == CONTENT_IGNORE) vmanip.m_data[i] = MapNode(CONTENT_STONE); } - else if(y <= WATER_LEVEL) - { - // Only modify places that have air or no content - if(vmanip.m_data[i].d == CONTENT_IGNORE - || vmanip.m_data[i].d == CONTENT_AIR) - vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE); - } - else - { - // Only modify places that have no content - if(vmanip.m_data[i].d == CONTENT_IGNORE) - vmanip.m_data[i] = MapNode(CONTENT_AIR); - }*/ data->vmanip.m_area.add_y(em, i, 1); } @@ -3247,22 +3363,24 @@ void makeBlock(BlockMakeData *data) */ { + PseudoRandom mineralrandom(blockseed); + /* Add meseblocks */ for(s16 i=0; iseed)+1.0)/2.0) + < dungeon_rarity + && node_min.Y < approx_groundlevel) { // Dungeon generator doesn't modify places which have this set data->vmanip.clearFlag(VMANIP_FLAG_DUNGEON_INSIDE @@ -3433,7 +3556,7 @@ void makeBlock(BlockMakeData *data) // Use fast index incrementing v3s16 em = vmanip.m_area.getExtent(); u32 i = vmanip.m_area.index(v3s16(p2d.X, full_node_max.Y, p2d.Y)); - for(s16 y=node_max.Y; y>=full_node_min.Y; y--) + for(s16 y=full_node_max.Y; y>=full_node_min.Y; y--) { if(vmanip.m_data[i].d == CONTENT_AIR) vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON_PRESERVE; @@ -3444,18 +3567,11 @@ void makeBlock(BlockMakeData *data) } } - /*s16 x = myrand_range(node_min.X, node_max.X); - s16 z = myrand_range(node_min.Z, node_max.Z); - s16 y = myrand_range(node_min.Y, node_max.Y);*/ + PseudoRandom random(blockseed+2); + // Add it - make_dungeon1(data->vmanip); + make_dungeon1(data->vmanip, random); - // Take different seed for every dungeon for not blending their - // mossyness together - //u32 mossyseed = z*38134234+y*42123+x*23; - u32 mossyseed = full_node_min.Z*38134234 - +full_node_min.Y*42123+full_node_min.X*23; - // Convert some cobble to mossy cobble for(s16 x=full_node_min.X; x<=full_node_max.X; x++) for(s16 z=full_node_min.Z; z<=full_node_max.Z; z++) @@ -3466,20 +3582,27 @@ void makeBlock(BlockMakeData *data) // Use fast index incrementing v3s16 em = vmanip.m_area.getExtent(); u32 i = vmanip.m_area.index(v3s16(p2d.X, full_node_max.Y, p2d.Y)); - for(s16 y=node_max.Y; y>=full_node_min.Y; y--) + for(s16 y=full_node_max.Y; y>=full_node_min.Y; y--) { - // No mossy in dry places - // (noisebuf not used because it's smaller in size) - if(noise3d_param(get_ground_wetness_params(data->seed), x,y,z) - < -0.6) - continue; - double d = noise3d_perlin((float)x/4., - (float)y/4.,(float)z/4., - mossyseed, 2, 0.9); - if(d < 0.0) - continue; + // (noisebuf not used because it doesn't contain the + // full area) + double wetness = noise3d_param( + get_ground_wetness_params(data->seed), x,y,z); + double d = noise3d_perlin((float)x/2.5, + (float)y/2.5,(float)z/2.5, + blockseed, 2, 1.4); if(vmanip.m_data[i].d == CONTENT_COBBLE) - vmanip.m_data[i].d = CONTENT_MOSSYCOBBLE; + { + if(d < wetness/3.0) + { + vmanip.m_data[i].d = CONTENT_MOSSYCOBBLE; + } + } + /*else if(vmanip.m_flags[i] & VMANIP_FLAG_DUNGEON_INSIDE) + { + if(wetness > 1.2) + vmanip.m_data[i].d = CONTENT_MUD; + }*/ data->vmanip.m_area.add_y(em, i, -1); } } @@ -3533,7 +3656,8 @@ void makeBlock(BlockMakeData *data) If close to ground level */ - if(abs(approx_ground_depth) < 20) + //if(abs(approx_ground_depth) < 30) + if(minimum_ground_depth < 5 && maximum_ground_depth > -5) { /* Add grass and mud @@ -3547,14 +3671,14 @@ void makeBlock(BlockMakeData *data) { bool possibly_have_sand = get_have_sand(data->seed, p2d); bool have_sand = false; - u32 mud_count = 0; + u32 current_depth = 0; bool air_detected = false; bool water_detected = false; // Use fast index incrementing s16 start_y = node_max.Y+2; v3s16 em = vmanip.m_area.getExtent(); u32 i = vmanip.m_area.index(v3s16(p2d.X, start_y, p2d.Y)); - for(s16 y=start_y; y>=node_min.Y-2; y--) + for(s16 y=start_y; y>=node_min.Y-3; y--) { if(vmanip.m_data[i].d == CONTENT_WATERSOURCE) water_detected = true; @@ -3568,24 +3692,37 @@ void makeBlock(BlockMakeData *data) || vmanip.m_data[i].d == CONTENT_GRAVEL ) && (air_detected || water_detected)) { - if(mud_count == 0 && y <= WATER_LEVEL+2 + if(current_depth == 0 && y <= WATER_LEVEL+2 && possibly_have_sand) have_sand = true; - - if(have_sand) + + if(current_depth < 4) { - vmanip.m_data[i] = MapNode(CONTENT_SAND); + if(have_sand) + { + vmanip.m_data[i] = MapNode(CONTENT_SAND); + } + #if 1 + else if(current_depth==0 && !water_detected + && y >= WATER_LEVEL && air_detected) + vmanip.m_data[i] = MapNode(CONTENT_GRASS); + #endif + else + vmanip.m_data[i] = MapNode(CONTENT_MUD); } - else if(mud_count==0 && !water_detected && y >= WATER_LEVEL) - vmanip.m_data[i] = MapNode(CONTENT_GRASS); else - vmanip.m_data[i] = MapNode(CONTENT_MUD); + { + if(vmanip.m_data[i].d == CONTENT_MUD + || vmanip.m_data[i].d == CONTENT_GRASS) + vmanip.m_data[i] = MapNode(CONTENT_STONE); + } - mud_count++; - if(mud_count >= 4) + current_depth++; + + if(current_depth >= 8) break; } - else if(mud_count != 0) + else if(current_depth != 0) break; data->vmanip.m_area.add_y(em, i, -1); @@ -3599,11 +3736,12 @@ void makeBlock(BlockMakeData *data) // Amount of trees u32 tree_count = block_area_nodes * tree_amount_2d(data->seed, p2d_center); + PseudoRandom treerandom(blockseed); // Put trees in random places on part of division for(u32 i=0; ivmanip, v2s16(x,z)); s16 y = find_ground_level_from_noise(data->seed, v2s16(x,z), 4); // Don't make a tree under water level @@ -3800,15 +3938,17 @@ MapBlock* ServerMap::finishBlockMake(BlockMakeData *data, /* Blit generated stuff to map + NOTE: blitBackAll adds nearly everything to changed_blocks */ { // 70ms @cs=8 //TimeTaker timer("finishBlockMake() blitBackAll"); data->vmanip.blitBackAll(&changed_blocks); } - - //dstream<<"changed_blocks.size()="< 32768/10) + { + //dstream<<"WARNING: PseudoRandom::range: max > 32767"< max) + { + assert(0); + return max; + } + return (next()%(max-min+1))+min; + } +private: + int m_next; +}; + double easeCurve(double t); // Return value: -1 ... 1 diff --git a/src/server.cpp b/src/server.cpp index 3036aef26..49eb15731 100644 --- a/src/server.cpp +++ b/src/server.cpp @@ -1720,7 +1720,7 @@ void Server::AsyncRunStep() // Don't send too many at a time count++; - if(count >= 2 && m_unsent_map_edit_queue.size() < 50) + if(count >= 1 && m_unsent_map_edit_queue.size() < 100) break; } } diff --git a/src/utility.h b/src/utility.h index 534aea483..497f79fa0 100644 --- a/src/utility.h +++ b/src/utility.h @@ -1741,6 +1741,11 @@ void mysrand(unsigned seed); inline int myrand_range(int min, int max) { + if(max-min > MYRAND_MAX) + { + dstream<<"WARNING: myrand_range: max-min > MYRAND_MAX"< max) { assert(0); -- cgit v1.2.3