Revert "Server::step throw is never catched. Replace it with an errorstream + assert" - minetest.git

diff options

author	kwolekr <kwolekr@minetest.net>	2015-03-16 21:17:27 -0400
committer	kwolekr <kwolekr@minetest.net>	2015-03-16 21:17:27 -0400
commit	699d42efc64cb1e317efbdf21dd55fdbef4c108c (patch)
tree	cde279404e6054f338c38077e775742de63db434 /src/content_mapnode.h
parent	ceac41ed6e2458e55f7277a9758dbea3cf907d74 (diff)
download	minetest-699d42efc64cb1e317efbdf21dd55fdbef4c108c.tar.gz minetest-699d42efc64cb1e317efbdf21dd55fdbef4c108c.tar.bz2 minetest-699d42efc64cb1e317efbdf21dd55fdbef4c108c.zip

Revert "Server::step throw is never catched. Replace it with an errorstream + assert"

This reverts commit 5f8e48c63baf12930430d5d8fc07495021599e61.

Diffstat (limited to 'src/content_mapnode.h')

0 files changed, 0 insertions, 0 deletions

/* Minetest Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com> This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser 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 "voxelalgorithms.h" #include "nodedef.h" #include "mapblock.h" #include "map.h" namespace voxalgo { void setLight(VoxelManipulator &v, VoxelArea a, u8 light, INodeDefManager *ndef) { for(s32 x=a.MinEdge.X; x<=a.MaxEdge.X; x++) for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++) for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++) { v3s16 p(x,y,z); MapNode &n = v.getNodeRefUnsafe(p); n.setLight(LIGHTBANK_DAY, light, ndef); n.setLight(LIGHTBANK_NIGHT, light, ndef); } } void clearLightAndCollectSources(VoxelManipulator &v, VoxelArea a, enum LightBank bank, INodeDefManager *ndef, std::set<v3s16> & light_sources, std::map<v3s16, u8> & unlight_from) { // The full area we shall touch VoxelArea required_a = a; required_a.pad(v3s16(0,0,0)); // Make sure we have access to it v.addArea(a); for(s32 x=a.MinEdge.X; x<=a.MaxEdge.X; x++) for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++) for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++) { v3s16 p(x,y,z); MapNode &n = v.getNodeRefUnsafe(p); u8 oldlight = n.getLight(bank, ndef); n.setLight(bank, 0, ndef); // If node sources light, add to list u8 source = ndef->get(n).light_source; if(source != 0) light_sources.insert(p); // Collect borders for unlighting if((x==a.MinEdge.X || x == a.MaxEdge.X || y==a.MinEdge.Y || y == a.MaxEdge.Y || z==a.MinEdge.Z || z == a.MaxEdge.Z) && oldlight != 0) { unlight_from[p] = oldlight; } } } SunlightPropagateResult propagateSunlight(VoxelManipulator &v, VoxelArea a, bool inexistent_top_provides_sunlight, std::set<v3s16> & light_sources, INodeDefManager *ndef) { // Return values bool bottom_sunlight_valid = true; // The full area we shall touch extends one extra at top and bottom VoxelArea required_a = a; required_a.pad(v3s16(0,1,0)); // Make sure we have access to it v.addArea(a); s16 max_y = a.MaxEdge.Y; s16 min_y = a.MinEdge.Y; for(s32 x=a.MinEdge.X; x<=a.MaxEdge.X; x++) for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++) { v3s16 p_overtop(x, max_y+1, z); bool overtop_has_sunlight = false; // If overtop node does not exist, trust heuristics if(!v.exists(p_overtop)) overtop_has_sunlight = inexistent_top_provides_sunlight; else if(v.getNodeRefUnsafe(p_overtop).getContent() == CONTENT_IGNORE) overtop_has_sunlight = inexistent_top_provides_sunlight; // Otherwise refer to it's light value else overtop_has_sunlight = (v.getNodeRefUnsafe(p_overtop).getLight( LIGHTBANK_DAY, ndef) == LIGHT_SUN); // Copy overtop's sunlight all over the place u8 incoming_light = overtop_has_sunlight ? LIGHT_SUN : 0; for(s32 y=max_y; y>=min_y; y--) { v3s16 p(x,y,z); MapNode &n = v.getNodeRefUnsafe(p); if(incoming_light == 0){ // Do nothing } else if(incoming_light == LIGHT_SUN && ndef->get(n).sunlight_propagates){ // Do nothing } else if(ndef->get(n).sunlight_propagates == false){ incoming_light = 0; } else { incoming_light = diminish_light(incoming_light); } u8 old_light = n.getLight(LIGHTBANK_DAY, ndef); if(incoming_light > old_light) n.setLight(LIGHTBANK_DAY, incoming_light, ndef); if(diminish_light(incoming_light) != 0) light_sources.insert(p); } // Check validity of sunlight at top of block below if it // hasn't already been proven invalid if(bottom_sunlight_valid) { bool sunlight_should_continue_down = (incoming_light == LIGHT_SUN); v3s16 p_overbottom(x, min_y-1, z); if(!v.exists(p_overbottom) || v.getNodeRefUnsafe(p_overbottom ).getContent() == CONTENT_IGNORE){ // Is not known, cannot compare } else { bool overbottom_has_sunlight = (v.getNodeRefUnsafe(p_overbottom ).getLight(LIGHTBANK_DAY, ndef) == LIGHT_SUN); if(sunlight_should_continue_down != overbottom_has_sunlight){ bottom_sunlight_valid = false; } } } } return SunlightPropagateResult(bottom_sunlight_valid); } /*! * A direction. * 0=X+ * 1=Y+ * 2=Z+ * 3=Z- * 4=Y- * 5=X- * 6=no direction * Two directions are opposite only if their sum is 5. */ typedef u8 direction; /*! * Relative node position. * This represents a node's position in its map block. * All coordinates must be between 0 and 15. */ typedef v3s16 relative_v3; /*! * Position of a map block (block coordinates). * One block_pos unit is as long as 16 node position units. */ typedef v3s16 mapblock_v3; //! Contains information about a node whose light is about to change. struct ChangingLight { //! Relative position of the node in its map block. relative_v3 rel_position; //! Position of the node's block. mapblock_v3 block_position; //! Pointer to the node's block. MapBlock *block; /*! * Direction from the node that caused this node's changing * to this node. */ direction source_direction; ChangingLight() : rel_position(), block_position(), block(NULL), source_direction(6) {} ChangingLight(relative_v3 rel_pos, mapblock_v3 block_pos, MapBlock *b, direction source_dir) : rel_position(rel_pos), block_position(block_pos), block(b), source_direction(source_dir) {} }; /*! * A fast, priority queue-like container to contain ChangingLights. * The ChangingLights are ordered by the given light levels. * The brightest ChangingLight is returned first. */ struct LightQueue { //! For each light level there is a vector. std::vector<ChangingLight> lights[LIGHT_SUN + 1]; //! Light of the brightest ChangingLight in the queue. u8 max_light; /*! * Creates a LightQueue. * \param reserve for each light level that many slots are reserved. */ LightQueue(size_t reserve) { max_light = LIGHT_SUN; for (u8 i = 0; i <= LIGHT_SUN; i++) { lights[i].reserve(reserve); } } /*! * Returns the next brightest ChangingLight and * removes it from the queue. * If there were no elements in the queue, the given parameters * remain unmodified. * \param light light level of the popped ChangingLight * \param data the ChangingLight that was popped * \returns true if there was a ChangingLight in the queue. */ bool next(u8 &light, ChangingLight &data) { while (lights[max_light].empty()) { if (max_light == 0) { return false; } max_light--; } light = max_light; data = lights[max_light].back(); lights[max_light].pop_back(); return true; } /*! * Adds an element to the queue. * The parameters are the same as in ChangingLight's constructor. * \param light light level of the ChangingLight */ inline void push(u8 light, const relative_v3 &rel_pos, const mapblock_v3 &block_pos, MapBlock *block, direction source_dir) { assert(light <= LIGHT_SUN); lights[light].push_back( ChangingLight(rel_pos, block_pos, block, source_dir)); } }; /*! * This type of light queue is for unlighting. * A node can be pushed in it only if its raw light is zero. * This prevents pushing nodes twice into this queue. * The light of the pushed ChangingLight must be the * light of the node before unlighting it. */ typedef LightQueue UnlightQueue; /*! * This type of light queue is for spreading lights. * While spreading lights, all the nodes in it must * have the same light as the light level the ChangingLights * were pushed into this queue with. This prevents unnecessary * re-pushing of the nodes into the queue. * If a node doesn't let light trough but emits light, it can be added * too. */ typedef LightQueue ReLightQueue; /*! * neighbor_dirs[i] points towards * the direction i. * See the definition of the type "direction" */ const static v3s16 neighbor_dirs[6] = { v3s16(1, 0, 0), // right v3s16(0, 1, 0), // top v3s16(0, 0, 1), // back v3s16(0, 0, -1), // front v3s16(0, -1, 0), // bottom v3s16(-1, 0, 0), // left }; /*! * Transforms the given map block offset by one node towards * the specified direction. * \param dir the direction of the transformation * \param rel_pos the node's relative position in its map block * \param block_pos position of the node's block */ bool step_rel_block_pos(direction dir, relative_v3 &rel_pos, mapblock_v3 &block_pos) { switch (dir) { case 0: if (rel_pos.X < MAP_BLOCKSIZE - 1) { rel_pos.X++; } else { rel_pos.X = 0; block_pos.X++; return true; } break; case 1: if (rel_pos.Y < MAP_BLOCKSIZE - 1) { rel_pos.Y++; } else { rel_pos.Y = 0; block_pos.Y++; return true; } break; case 2: if (rel_pos.Z < MAP_BLOCKSIZE - 1) { rel_pos.Z++; } else { rel_pos.Z = 0; block_pos.Z++; return true; } break; case 3: if (rel_pos.Z > 0) { rel_pos.Z--; } else { rel_pos.Z = MAP_BLOCKSIZE - 1; block_pos.Z--; return true; } break; case 4: if (rel_pos.Y > 0) { rel_pos.Y--; } else { rel_pos.Y = MAP_BLOCKSIZE - 1; block_pos.Y--; return true; } break; case 5: if (rel_pos.X > 0) { rel_pos.X--; } else { rel_pos.X = MAP_BLOCKSIZE - 1; block_pos.X--; return true; } break; } return false; } /* * Removes all light that is potentially emitted by the specified * light sources. These nodes will have zero light. * Returns all nodes whose light became zero but should be re-lighted. * * \param bank the light bank in which the procedure operates * \param from_nodes nodes whose light is removed * \param light_sources nodes that should be re-lighted * \param modified_blocks output, all modified map blocks are added to this */ void unspread_light(Map *map, INodeDefManager *nodemgr, LightBank bank, UnlightQueue &from_nodes, ReLightQueue &light_sources, std::map<v3s16, MapBlock*> &modified_blocks) { // Stores data popped from from_nodes u8 current_light; ChangingLight current; // Data of the current neighbor mapblock_v3 neighbor_block_pos; relative_v3 neighbor_rel_pos; // A dummy boolean bool is_valid_position; // Direction of the brightest neighbor of the node direction source_dir; while (from_nodes.next(current_light, current)) { // For all nodes that need unlighting // There is no brightest neighbor source_dir = 6; // The current node const MapNode &node = current.block->getNodeNoCheck( current.rel_position, &is_valid_position); const ContentFeatures &f = nodemgr->get(node); // If the node emits light, it behaves like it had a // brighter neighbor. u8 brightest_neighbor_light = f.light_source + 1; for (direction i = 0; i < 6; i++) { //For each neighbor // The node that changed this node has already zero light // and it can't give light to this node if (current.source_direction + i == 5) { continue; } // Get the neighbor's position and block neighbor_rel_pos = current.rel_position; neighbor_block_pos = current.block_position; MapBlock *neighbor_block; if (step_rel_block_pos(i, neighbor_rel_pos, neighbor_block_pos)) { neighbor_block = map->getBlockNoCreateNoEx(neighbor_block_pos); if (neighbor_block == NULL) { current.block->setLightingComplete(bank, i, false); continue; } } else { neighbor_block = current.block; } // Get the neighbor itself MapNode neighbor = neighbor_block->getNodeNoCheck(neighbor_rel_pos, &is_valid_position); const ContentFeatures &neighbor_f = nodemgr->get( neighbor.getContent()); u8 neighbor_light = neighbor.getLightRaw(bank, neighbor_f); // If the neighbor has at least as much light as this node, then // it won't lose its light, since it should have been added to // from_nodes earlier, so its light would be zero. if (neighbor_f.light_propagates && neighbor_light < current_light) { // Unlight, but only if the node has light. if (neighbor_light > 0) { neighbor.setLight(bank, 0, neighbor_f); neighbor_block->setNodeNoCheck(neighbor_rel_pos, neighbor); from_nodes.push(neighbor_light, neighbor_rel_pos, neighbor_block_pos, neighbor_block, i); // The current node was modified earlier, so its block // is in modified_blocks. if (current.block != neighbor_block) { modified_blocks[neighbor_block_pos] = neighbor_block; } } } else { // The neighbor can light up this node. if (neighbor_light < neighbor_f.light_source) { neighbor_light = neighbor_f.light_source; } if (brightest_neighbor_light < neighbor_light) { brightest_neighbor_light = neighbor_light; source_dir = i; } } } // If the brightest neighbor is able to light up this node, // then add this node to the output nodes. if (brightest_neighbor_light > 1 && f.light_propagates) { brightest_neighbor_light--; light_sources.push(brightest_neighbor_light, current.rel_position, current.block_position, current.block, (source_dir == 6) ? 6 : 5 - source_dir /* with opposite direction*/); } } } /* * Spreads light from the specified starting nodes. * * Before calling this procedure, make sure that all ChangingLights * in light_sources have as much light on the map as they have in * light_sources (if the queue contains a node multiple times, the brightest * occurrence counts). * * \param bank the light bank in which the procedure operates * \param light_sources starting nodes * \param modified_blocks output, all modified map blocks are added to this */ void spread_light(Map *map, INodeDefManager *nodemgr, LightBank bank, LightQueue &light_sources, std::map<v3s16, MapBlock*> &modified_blocks) { // The light the current node can provide to its neighbors. u8 spreading_light; // The ChangingLight for the current node. ChangingLight current; // Position of the current neighbor. mapblock_v3 neighbor_block_pos; relative_v3 neighbor_rel_pos; // A dummy boolean. bool is_valid_position; while (light_sources.next(spreading_light, current)) { spreading_light--; for (direction i = 0; i < 6; i++) { // This node can't light up its light source if (current.source_direction + i == 5) { continue; } // Get the neighbor's position and block neighbor_rel_pos = current.rel_position; neighbor_block_pos = current.block_position; MapBlock *neighbor_block; if (step_rel_block_pos(i, neighbor_rel_pos, neighbor_block_pos)) { neighbor_block = map->getBlockNoCreateNoEx(neighbor_block_pos); if (neighbor_block == NULL) { current.block->setLightingComplete(bank, i, false); continue; } } else { neighbor_block = current.block; } // Get the neighbor itself MapNode neighbor = neighbor_block->getNodeNoCheck(neighbor_rel_pos, &is_valid_position); const ContentFeatures &f = nodemgr->get(neighbor.getContent()); if (f.light_propagates) { // Light up the neighbor, if it has less light than it should. u8 neighbor_light = neighbor.getLightRaw(bank, f); if (neighbor_light < spreading_light) { neighbor.setLight(bank, spreading_light, f); neighbor_block->setNodeNoCheck(neighbor_rel_pos, neighbor); light_sources.push(spreading_light, neighbor_rel_pos, neighbor_block_pos, neighbor_block, i); // The current node was modified earlier, so its block // is in modified_blocks. if (current.block != neighbor_block) { modified_blocks[neighbor_block_pos] = neighbor_block; } } } } } } struct SunlightPropagationUnit{ v2s16 relative_pos; bool is_sunlit; SunlightPropagationUnit(v2s16 relpos, bool sunlit): relative_pos(relpos), is_sunlit(sunlit) {} }; struct SunlightPropagationData{ std::vector<SunlightPropagationUnit> data; v3s16 target_block; }; /*! * Returns true if the node gets sunlight from the * node above it. * * \param pos position of the node. */ bool is_sunlight_above(Map *map, v3s16 pos, INodeDefManager *ndef) { bool sunlight = true; mapblock_v3 source_block_pos; relative_v3 source_rel_pos; getNodeBlockPosWithOffset(pos + v3s16(0, 1, 0), source_block_pos, source_rel_pos); // If the node above has sunlight, this node also can get it. MapBlock *source_block = map->getBlockNoCreateNoEx(source_block_pos); if (source_block == NULL) { // But if there is no node above, then use heuristics MapBlock *node_block = map->getBlockNoCreateNoEx(getNodeBlockPos(pos)); if (node_block == NULL) { sunlight = false; } else { sunlight = !node_block->getIsUnderground(); } } else { bool is_valid_position; MapNode above = source_block->getNodeNoCheck(source_rel_pos, &is_valid_position); if (is_valid_position) { if (above.getContent() == CONTENT_IGNORE) { // Trust heuristics if (source_block->getIsUnderground()) { sunlight = false; } } else if (above.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN) { // If the node above doesn't have sunlight, this // node is in shadow. sunlight = false; } } } return sunlight; } static const LightBank banks[] = { LIGHTBANK_DAY, LIGHTBANK_NIGHT }; void update_lighting_nodes(Map *map, std::vector<std::pair<v3s16, MapNode> > &oldnodes, std::map<v3s16, MapBlock*> &modified_blocks) { INodeDefManager *ndef = map->getNodeDefManager(); // For node getter functions bool is_valid_position; // Process each light bank separately for (s32 i = 0; i < 2; i++) { LightBank bank = banks[i]; UnlightQueue disappearing_lights(256); ReLightQueue light_sources(256); // Nodes that are brighter than the brightest modified node was // won't change, since they didn't get their light from a // modified node. u8 min_safe_light = 0; for (std::vector<std::pair<v3s16, MapNode> >::iterator it = oldnodes.begin(); it < oldnodes.end(); ++it) { u8 old_light = it->second.getLight(bank, ndef); if (old_light > min_safe_light) { min_safe_light = old_light; } } // If only one node changed, even nodes with the same brightness // didn't get their light from the changed node. if (oldnodes.size() > 1) { min_safe_light++; } // For each changed node process sunlight and initialize for (std::vector<std::pair<v3s16, MapNode> >::iterator it = oldnodes.begin(); it < oldnodes.end(); ++it) { // Get position and block of the changed node v3s16 p = it->first; relative_v3 rel_pos; mapblock_v3 block_pos; getNodeBlockPosWithOffset(p, block_pos, rel_pos); MapBlock *block = map->getBlockNoCreateNoEx(block_pos); if (block == NULL || block->isDummy()) { continue; } // Get the new node MapNode n = block->getNodeNoCheck(rel_pos, &is_valid_position); if (!is_valid_position) { break; } // Light of the old node u8 old_light = it->second.getLight(bank, ndef); // Add the block of the added node to modified_blocks modified_blocks[block_pos] = block; // Get new light level of the node u8 new_light = 0; if (ndef->get(n).light_propagates) { if (bank == LIGHTBANK_DAY && ndef->get(n).sunlight_propagates && is_sunlight_above(map, p, ndef)) { new_light = LIGHT_SUN; } else { new_light = ndef->get(n).light_source; for (int i = 0; i < 6; i++) { v3s16 p2 = p + neighbor_dirs[i]; bool is_valid; MapNode n2 = map->getNodeNoEx(p2, &is_valid); if (is_valid) { u8 spread = n2.getLight(bank, ndef); // If it is sure that the neighbor won't be // unlighted, its light can spread to this node. if (spread > new_light && spread >= min_safe_light) { new_light = spread - 1; } } } } } else { // If this is an opaque node, it still can emit light. new_light = ndef->get(n).light_source; } if (new_light > 0) { light_sources.push(new_light, rel_pos, block_pos, block, 6); } if (new_light < old_light) { // The node became opaque or doesn't provide as much // light as the previous one, so it must be unlighted. // Add to unlight queue n.setLight(bank, 0, ndef); block->setNodeNoCheck(rel_pos, n); disappearing_lights.push(old_light, rel_pos, block_pos, block, 6); // Remove sunlight, if there was any if (bank == LIGHTBANK_DAY && old_light == LIGHT_SUN) { for (s16 y = p.Y - 1;; y--) { v3s16 n2pos(p.X, y, p.Z); MapNode n2; n2 = map->getNodeNoEx(n2pos, &is_valid_position); if (!is_valid_position) break; // If this node doesn't have sunlight, the nodes below // it don't have too. if (n2.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN) { break; } // Remove sunlight and add to unlight queue. n2.setLight(LIGHTBANK_DAY, 0, ndef); map->setNode(n2pos, n2); relative_v3 rel_pos2; mapblock_v3 block_pos2; getNodeBlockPosWithOffset(n2pos, block_pos2, rel_pos2); MapBlock *block2 = map->getBlockNoCreateNoEx( block_pos2); disappearing_lights.push(LIGHT_SUN, rel_pos2, block_pos2, block2, 4 /* The node above caused the change */); } } } else if (new_light > old_light) { // It is sure that the node provides more light than the previous // one, unlighting is not necessary. // Propagate sunlight if (bank == LIGHTBANK_DAY && new_light == LIGHT_SUN) { for (s16 y = p.Y - 1;; y--) { v3s16 n2pos(p.X, y, p.Z); MapNode n2; n2 = map->getNodeNoEx(n2pos, &is_valid_position); if (!is_valid_position) break; // This should not happen, but if the node has sunlight // then the iteration should stop. if (n2.getLight(LIGHTBANK_DAY, ndef) == LIGHT_SUN) { break; } // If the node terminates sunlight, stop. if (!ndef->get(n2).sunlight_propagates) { break; } relative_v3 rel_pos2; mapblock_v3 block_pos2; getNodeBlockPosWithOffset(n2pos, block_pos2, rel_pos2); MapBlock *block2 = map->getBlockNoCreateNoEx( block_pos2); // Mark node for lighting. light_sources.push(LIGHT_SUN, rel_pos2, block_pos2, block2, 4); } } } } // Remove lights unspread_light(map, ndef, bank, disappearing_lights, light_sources, modified_blocks); // Initialize light values for light spreading. for (u8 i = 0; i <= LIGHT_SUN; i++) { const std::vector<ChangingLight> &lights = light_sources.lights[i]; for (std::vector<ChangingLight>::const_iterator it = lights.begin(); it < lights.end(); ++it) { MapNode n = it->block->getNodeNoCheck(it->rel_position, &is_valid_position); n.setLight(bank, i, ndef); it->block->setNodeNoCheck(it->rel_position, n); } } // Spread lights. spread_light(map, ndef, bank, light_sources, modified_blocks); } } /*! * Borders of a map block in relative node coordinates. * Compatible with type 'direction'. */ const VoxelArea block_borders[] = { VoxelArea(v3s16(15, 0, 0), v3s16(15, 15, 15)), //X+ VoxelArea(v3s16(0, 15, 0), v3s16(15, 15, 15)), //Y+ VoxelArea(v3s16(0, 0, 15), v3s16(15, 15, 15)), //Z+ VoxelArea(v3s16(0, 0, 0), v3s16(15, 15, 0)), //Z- VoxelArea(v3s16(0, 0, 0), v3s16(15, 0, 15)), //Y- VoxelArea(v3s16(0, 0, 0), v3s16(0, 15, 15)) //X- }; /*! * Returns true if: * -the node has unloaded neighbors * -the node doesn't have light * -the node's light is the same as the maximum of * its light source and its brightest neighbor minus one. * . */ bool is_light_locally_correct(Map *map, INodeDefManager *ndef, LightBank bank, v3s16 pos) { bool is_valid_position; MapNode n = map->getNodeNoEx(pos, &is_valid_position); const ContentFeatures &f = ndef->get(n); if (f.param_type != CPT_LIGHT) { return true; } u8 light = n.getLightNoChecks(bank, &f); assert(f.light_source <= LIGHT_MAX); u8 brightest_neighbor = f.light_source + 1; for (direction d = 0; d < 6; ++d) { MapNode n2 = map->getNodeNoEx(pos + neighbor_dirs[d], &is_valid_position); u8 light2 = n2.getLight(bank, ndef); if (brightest_neighbor < light2) { brightest_neighbor = light2; } } assert(light <= LIGHT_SUN); return brightest_neighbor == light + 1; } void update_block_border_lighting(Map *map, MapBlock *block, std::map<v3s16, MapBlock*> &modified_blocks) { INodeDefManager *ndef = map->getNodeDefManager(); bool is_valid_position; for (s32 i = 0; i < 2; i++) { LightBank bank = banks[i]; // Since invalid light is not common, do not allocate // memory if not needed. UnlightQueue disappearing_lights(0); ReLightQueue light_sources(0); // Get incorrect lights for (direction d = 0; d < 6; d++) { // For each direction // Get neighbor block v3s16 otherpos = block->getPos() + neighbor_dirs[d]; MapBlock *other = map->getBlockNoCreateNoEx(otherpos); if (other == NULL) { continue; } // Only update if lighting was not completed. if (block->isLightingComplete(bank, d) && other->isLightingComplete(bank, 5 - d)) continue; // Reset flags block->setLightingComplete(bank, d, true); other->setLightingComplete(bank, 5 - d, true); // The two blocks and their connecting surfaces MapBlock *blocks[] = {block, other}; VoxelArea areas[] = {block_borders[d], block_borders[5 - d]}; // For both blocks for (u8 blocknum = 0; blocknum < 2; blocknum++) { MapBlock *b = blocks[blocknum]; VoxelArea a = areas[blocknum]; // For all nodes for (s32 x = a.MinEdge.X; x <= a.MaxEdge.X; x++) for (s32 z = a.MinEdge.Z; z <= a.MaxEdge.Z; z++) for (s32 y = a.MinEdge.Y; y <= a.MaxEdge.Y; y++) { MapNode n = b->getNodeNoCheck(x, y, z, &is_valid_position); u8 light = n.getLight(bank, ndef); // Sunlight is fixed if (light < LIGHT_SUN) { // Unlight if not correct if (!is_light_locally_correct(map, ndef, bank, v3s16(x, y, z) + b->getPosRelative())) { // Initialize for unlighting n.setLight(bank, 0, ndef); b->setNodeNoCheck(x, y, z, n); modified_blocks[b->getPos()]=b; disappearing_lights.push(light, relative_v3(x, y, z), b->getPos(), b, 6); } } } } } // Remove lights unspread_light(map, ndef, bank, disappearing_lights, light_sources, modified_blocks); // Initialize light values for light spreading. for (u8 i = 0; i <= LIGHT_SUN; i++) { const std::vector<ChangingLight> &lights = light_sources.lights[i]; for (std::vector<ChangingLight>::const_iterator it = lights.begin(); it < lights.end(); ++it) { MapNode n = it->block->getNodeNoCheck(it->rel_position, &is_valid_position); n.setLight(bank, i, ndef); it->block->setNodeNoCheck(it->rel_position, n); } } // Spread lights. spread_light(map, ndef, bank, light_sources, modified_blocks); } } /*! * Resets the lighting of the given VoxelManipulator to * complete darkness and full sunlight. * Operates in one map sector. * * \param offset contains the least x and z node coordinates * of the map sector. * \param light incoming sunlight, light[x][z] is true if there * is sunlight above the voxel manipulator at the given x-z coordinates. * The array's indices are relative node coordinates in the sector. * After the procedure returns, this contains outgoing light at * the bottom of the voxel manipulator. */ void fill_with_sunlight(MMVManip *vm, INodeDefManager *ndef, v2s16 offset, bool light[MAP_BLOCKSIZE][MAP_BLOCKSIZE]) { // Distance in array between two nodes on top of each other. s16 ystride = vm->m_area.getExtent().X; // Cache the ignore node. MapNode ignore = MapNode(CONTENT_IGNORE); // For each column of nodes: for (s16 z = 0; z < MAP_BLOCKSIZE; z++) for (s16 x = 0; x < MAP_BLOCKSIZE; x++) { // Position of the column on the map. v2s16 realpos = offset + v2s16(x, z); // Array indices in the voxel manipulator s32 maxindex = vm->m_area.index(realpos.X, vm->m_area.MaxEdge.Y, realpos.Y); s32 minindex = vm->m_area.index(realpos.X, vm->m_area.MinEdge.Y, realpos.Y); // True if the current node has sunlight. bool lig = light[z][x]; // For each node, downwards: for (s32 i = maxindex; i >= minindex; i -= ystride) { MapNode *n; if (vm->m_flags[i] & VOXELFLAG_NO_DATA) n = &ignore; else n = &vm->m_data[i]; // Ignore IGNORE nodes, these are not generated yet. if(n->getContent() == CONTENT_IGNORE) continue; const ContentFeatures &f = ndef->get(n->getContent()); if (lig && !f.sunlight_propagates) // Sunlight is stopped. lig = false; // Reset light n->setLight(LIGHTBANK_DAY, lig ? 15 : 0, f); n->setLight(LIGHTBANK_NIGHT, 0, f); } // Output outgoing light. light[z][x] = lig; } } /*! * Returns incoming sunlight for one map block. * If block above is not found, it is loaded. * * \param pos position of the map block that gets the sunlight. * \param light incoming sunlight, light[z][x] is true if there * is sunlight above the block at the given z-x relative * node coordinates. */ void is_sunlight_above_block(ServerMap *map, mapblock_v3 pos, INodeDefManager *ndef, bool light[MAP_BLOCKSIZE][MAP_BLOCKSIZE]) { mapblock_v3 source_block_pos = pos + v3s16(0, 1, 0); // Get or load source block. // It might take a while to load, but correcting incorrect // sunlight may be even slower. MapBlock *source_block = map->emergeBlock(source_block_pos, false); // Trust only generated blocks. if (source_block == NULL || source_block->isDummy() || !source_block->isGenerated()) { // But if there is no block above, then use heuristics bool sunlight = true; MapBlock *node_block = map->getBlockNoCreateNoEx(pos); if (node_block == NULL) // This should not happen. sunlight = false; else sunlight = !node_block->getIsUnderground(); for (s16 z = 0; z < MAP_BLOCKSIZE; z++) for (s16 x = 0; x < MAP_BLOCKSIZE; x++) light[z][x] = sunlight; } else { // Dummy boolean, the position is valid. bool is_valid_position; // For each column: for (s16 z = 0; z < MAP_BLOCKSIZE; z++) for (s16 x = 0; x < MAP_BLOCKSIZE; x++) { // Get the bottom block. MapNode above = source_block->getNodeNoCheck(x, 0, z, &is_valid_position); light[z][x] = above.getLight(LIGHTBANK_DAY, ndef) == LIGHT_SUN; } } } /*! * Propagates sunlight down in a given map block. * * \param data contains incoming sunlight and shadow and * the coordinates of the target block. * \param unlight propagated shadow is inserted here * \param relight propagated sunlight is inserted here * * \returns true if the block was modified, false otherwise. */ bool propagate_block_sunlight(Map *map, INodeDefManager *ndef, SunlightPropagationData *data, UnlightQueue *unlight, ReLightQueue *relight) { bool modified = false; // Get the block. MapBlock *block = map->getBlockNoCreateNoEx(data->target_block); if (block == NULL || block->isDummy()) { // The work is done if the block does not contain data. data->data.clear(); return false; } // Dummy boolean bool is_valid; // For each changing column of nodes: size_t index; for (index = 0; index < data->data.size(); index++) { SunlightPropagationUnit it = data->data[index]; // Relative position of the currently inspected node. relative_v3 current_pos(it.relative_pos.X, MAP_BLOCKSIZE - 1, it.relative_pos.Y); if (it.is_sunlit) { // Propagate sunlight. // For each node downwards: for (; current_pos.Y >= 0; current_pos.Y--) { MapNode n = block->getNodeNoCheck(current_pos, &is_valid); const ContentFeatures &f = ndef->get(n); if (n.getLightRaw(LIGHTBANK_DAY, f) < LIGHT_SUN && f.sunlight_propagates) { // This node gets sunlight. n.setLight(LIGHTBANK_DAY, LIGHT_SUN, f); block->setNodeNoCheck(current_pos, n); modified = true; relight->push(LIGHT_SUN, current_pos, data->target_block, block, 4); } else { // Light already valid, propagation stopped. break; } } } else { // Propagate shadow. // For each node downwards: for (; current_pos.Y >= 0; current_pos.Y--) { MapNode n = block->getNodeNoCheck(current_pos, &is_valid); const ContentFeatures &f = ndef->get(n); if (n.getLightRaw(LIGHTBANK_DAY, f) == LIGHT_SUN) { // The sunlight is no longer valid. n.setLight(LIGHTBANK_DAY, 0, f); block->setNodeNoCheck(current_pos, n); modified = true; unlight->push(LIGHT_SUN, current_pos, data->target_block, block, 4); } else { // Reached shadow, propagation stopped. break; } } } if (current_pos.Y >= 0) { // Propagation stopped, remove from data. data->data[index] = data->data.back(); data->data.pop_back(); index--; } } return modified; } /*! * Borders of a map block in relative node coordinates. * The areas do not overlap. * Compatible with type 'direction'. */ const VoxelArea block_pad[] = { VoxelArea(v3s16(15, 0, 0), v3s16(15, 15, 15)), //X+ VoxelArea(v3s16(1, 15, 0), v3s16(14, 15, 15)), //Y+ VoxelArea(v3s16(1, 1, 15), v3s16(14, 14, 15)), //Z+ VoxelArea(v3s16(1, 1, 0), v3s16(14, 14, 0)), //Z- VoxelArea(v3s16(1, 0, 0), v3s16(14, 0, 15)), //Y- VoxelArea(v3s16(0, 0, 0), v3s16(0, 15, 15)) //X- }; /*! * The common part of bulk light updates - it is always executed. * The procedure takes the nodes that should be unlit, and the * full modified area. * * The procedure handles the correction of all lighting except * direct sunlight spreading. * * \param minblock least coordinates of the changed area in block * coordinates * \param maxblock greatest coordinates of the changed area in block * coordinates * \param unlight the first queue is for day light, the second is for * night light. Contains all nodes on the borders that need to be unlit. * \param relight the first queue is for day light, the second is for * night light. Contains nodes that were not modified, but got sunlight * because the changes. * \param modified_blocks the procedure adds all modified blocks to * this map */ void finish_bulk_light_update(Map *map, mapblock_v3 minblock, mapblock_v3 maxblock, UnlightQueue unlight[2], ReLightQueue relight[2], std::map<v3s16, MapBlock*> *modified_blocks) { INodeDefManager *ndef = map->getNodeDefManager(); // dummy boolean bool is_valid; // --- STEP 1: Do unlighting for (size_t bank = 0; bank < 2; bank++) { LightBank b = banks[bank]; unspread_light(map, ndef, b, unlight[bank], relight[bank], *modified_blocks); } // --- STEP 2: Get all newly inserted light sources // For each block: for (s16 b_x = minblock.X; b_x <= maxblock.X; b_x++) for (s16 b_y = minblock.Y; b_y <= maxblock.Y; b_y++) for (s16 b_z = minblock.Z; b_z <= maxblock.Z; b_z++) { const v3s16 blockpos(b_x, b_y, b_z); MapBlock *block = map->getBlockNoCreateNoEx(blockpos); if (!block || block->isDummy()) // Skip not existing blocks continue; // For each node in the block: for (s32 x = 0; x < MAP_BLOCKSIZE; x++) for (s32 z = 0; z < MAP_BLOCKSIZE; z++) for (s32 y = 0; y < MAP_BLOCKSIZE; y++) { v3s16 relpos(x, y, z); MapNode node = block->getNodeNoCheck(x, y, z, &is_valid); const ContentFeatures &f = ndef->get(node); // For each light bank for (size_t b = 0; b < 2; b++) { LightBank bank = banks[b]; u8 light = f.param_type == CPT_LIGHT ? node.getLightNoChecks(bank, &f): f.light_source; if (light > 1) relight[b].push(light, relpos, blockpos, block, 6); } // end of banks } // end of nodes } // end of blocks // --- STEP 3: do light spreading // For each light bank: for (size_t b = 0; b < 2; b++) { LightBank bank = banks[b]; // Sunlight is already initialized. u8 maxlight = (b == 0) ? LIGHT_MAX : LIGHT_SUN;


context:
space:
mode: