mirror of
https://github.com/luanti-org/luanti.git
synced 2025-06-27 16:36:03 +00:00
Reworked texture, material, mineral and whatever handling
This commit is contained in:
Perttu Ahola
parent
035345f13d
commit
9f882bf74d
27 changed files with 952 additions and 1324 deletions
635
src/voxel.cpp
635
src/voxel.cpp
|
|
@ -110,7 +110,7 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
|
|||
if(pr <= 9)
|
||||
c = pr + '0';
|
||||
}
|
||||
else if(liquid_replaces_content(m))
|
||||
else if(m == CONTENT_AIR)
|
||||
{
|
||||
c = ' ';
|
||||
}
|
||||
|
|
@ -653,637 +653,4 @@ void VoxelManipulator::spreadLight(enum LightBank bank,
|
|||
}
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
int VoxelManipulator::getWaterPressure(v3s16 p, s16 &highest_y, int recur_count)
|
||||
{
|
||||
m_flags[m_area.index(p)] |= VOXELFLAG_CHECKED2;
|
||||
|
||||
if(p.Y > highest_y)
|
||||
highest_y = p.Y;
|
||||
|
||||
/*if(recur_count > 1000)
|
||||
throw ProcessingLimitException
|
||||
("getWaterPressure recur_count limit reached");*/
|
||||
|
||||
if(recur_count > 10000)
|
||||
return -1;
|
||||
|
||||
recur_count++;
|
||||
|
||||
v3s16 dirs[6] = {
|
||||
v3s16(0,1,0), // top
|
||||
v3s16(0,0,1), // back
|
||||
v3s16(0,0,-1), // front
|
||||
v3s16(1,0,0), // right
|
||||
v3s16(-1,0,0), // left
|
||||
v3s16(0,-1,0), // bottom
|
||||
};
|
||||
|
||||
// Load neighboring nodes
|
||||
emerge(VoxelArea(p - v3s16(1,1,1), p + v3s16(1,1,1)), 1);
|
||||
|
||||
s32 i;
|
||||
for(i=0; i<6; i++)
|
||||
{
|
||||
v3s16 p2 = p + dirs[i];
|
||||
u8 f = m_flags[m_area.index(p2)];
|
||||
// Ignore inexistent or checked nodes
|
||||
if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED2))
|
||||
continue;
|
||||
MapNode &n = m_data[m_area.index(p2)];
|
||||
// Ignore non-liquid nodes
|
||||
if(content_liquid(n.d) == false)
|
||||
continue;
|
||||
|
||||
int pr;
|
||||
|
||||
// If at ocean surface
|
||||
if(n.pressure == 1 && n.d == CONTENT_WATERSOURCE)
|
||||
//if(n.pressure == 1) // Causes glitches but is fast
|
||||
{
|
||||
pr = 1;
|
||||
}
|
||||
// Otherwise recurse more
|
||||
else
|
||||
{
|
||||
pr = getWaterPressure(p2, highest_y, recur_count);
|
||||
if(pr == -1)
|
||||
continue;
|
||||
}
|
||||
|
||||
// If block is at top, pressure here is one higher
|
||||
if(i == 0)
|
||||
{
|
||||
if(pr < 255)
|
||||
pr++;
|
||||
}
|
||||
// If block is at bottom, pressure here is one lower
|
||||
else if(i == 5)
|
||||
{
|
||||
if(pr > 1)
|
||||
pr--;
|
||||
}
|
||||
|
||||
// Node is on the pressure route
|
||||
m_flags[m_area.index(p)] |= VOXELFLAG_CHECKED4;
|
||||
|
||||
// Got pressure
|
||||
return pr;
|
||||
}
|
||||
|
||||
// Nothing useful found
|
||||
return -1;
|
||||
}
|
||||
|
||||
void VoxelManipulator::spreadWaterPressure(v3s16 p, int pr,
|
||||
VoxelArea request_area,
|
||||
core::map<v3s16, u8> &active_nodes,
|
||||
int recur_count)
|
||||
{
|
||||
//if(recur_count > 10000)
|
||||
/*throw ProcessingLimitException
|
||||
("spreadWaterPressure recur_count limit reached");*/
|
||||
if(recur_count > 10)
|
||||
return;
|
||||
recur_count++;
|
||||
|
||||
/*dstream<<"spreadWaterPressure: p=("
|
||||
<<p.X<<","<<p.Y<<","<<p.Z<<")"
|
||||
<<", oldpr="<<(int)m_data[m_area.index(p)].pressure
|
||||
<<", pr="<<pr
|
||||
<<", recur_count="<<recur_count
|
||||
<<", request_area=";
|
||||
request_area.print(dstream);
|
||||
dstream<<std::endl;*/
|
||||
|
||||
m_flags[m_area.index(p)] |= VOXELFLAG_CHECKED3;
|
||||
m_data[m_area.index(p)].pressure = pr;
|
||||
|
||||
v3s16 dirs[6] = {
|
||||
v3s16(0,1,0), // top
|
||||
v3s16(-1,0,0), // left
|
||||
v3s16(1,0,0), // right
|
||||
v3s16(0,0,-1), // front
|
||||
v3s16(0,0,1), // back
|
||||
v3s16(0,-1,0), // bottom
|
||||
};
|
||||
|
||||
// Load neighboring nodes
|
||||
emerge(VoxelArea(p - v3s16(1,1,1), p + v3s16(1,1,1)), 2);
|
||||
|
||||
s32 i;
|
||||
for(i=0; i<6; i++)
|
||||
{
|
||||
v3s16 p2 = p + dirs[i];
|
||||
|
||||
u8 f = m_flags[m_area.index(p2)];
|
||||
|
||||
// Ignore inexistent and checked nodes
|
||||
if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED3))
|
||||
continue;
|
||||
|
||||
MapNode &n = m_data[m_area.index(p2)];
|
||||
|
||||
/*
|
||||
If material is air:
|
||||
add to active_nodes if there is flow-causing pressure.
|
||||
NOTE: Do not remove anything from there. We cannot know
|
||||
here if some other neighbor of it causes flow.
|
||||
*/
|
||||
if(liquid_replaces_content(n.d))
|
||||
{
|
||||
bool pressure_causes_flow = false;
|
||||
// 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;
|
||||
}
|
||||
// If block is at bottom
|
||||
else if(i == 5)
|
||||
{
|
||||
pressure_causes_flow = true;
|
||||
}
|
||||
// If block is at side
|
||||
else
|
||||
{
|
||||
//if(pr >= PRESERVE_WATER_VOLUME ? 2 : 1)
|
||||
if(pr >= 2)
|
||||
pressure_causes_flow = true;
|
||||
}
|
||||
|
||||
if(pressure_causes_flow)
|
||||
{
|
||||
active_nodes[p2] = 1;
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
// Ignore non-liquid nodes
|
||||
if(content_liquid(n.d) == false)
|
||||
continue;
|
||||
|
||||
int pr2 = pr;
|
||||
// If block is at top, pressure there is lower
|
||||
if(i == 0)
|
||||
{
|
||||
if(pr2 > 0)
|
||||
pr2--;
|
||||
}
|
||||
// If block is at bottom, pressure there is higher
|
||||
else if(i == 5)
|
||||
{
|
||||
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.
|
||||
// Thus, request_area can be used for updating as much
|
||||
// pressure info in some area as possible to possibly
|
||||
// make some calls to getWaterPressure unnecessary.
|
||||
if(n.pressure == pr2 && request_area.contains(p2) == false)
|
||||
continue;
|
||||
|
||||
spreadWaterPressure(p2, pr2, request_area, active_nodes, recur_count);
|
||||
}
|
||||
}
|
||||
|
||||
void VoxelManipulator::updateAreaWaterPressure(VoxelArea a,
|
||||
core::map<v3s16, u8> &active_nodes,
|
||||
bool checked3_is_clear)
|
||||
{
|
||||
TimeTaker timer("updateAreaWaterPressure", &updateareawaterpressure_time);
|
||||
|
||||
emerge(a, 3);
|
||||
|
||||
bool checked2_clear = false;
|
||||
|
||||
if(checked3_is_clear == false)
|
||||
{
|
||||
//clearFlag(VOXELFLAG_CHECKED3);
|
||||
|
||||
clearFlag(VOXELFLAG_CHECKED3 | VOXELFLAG_CHECKED2);
|
||||
checked2_clear = true;
|
||||
}
|
||||
|
||||
|
||||
for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
|
||||
for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
|
||||
for(s32 x=a.MinEdge.X; x<=a.MaxEdge.X; x++)
|
||||
{
|
||||
v3s16 p(x,y,z);
|
||||
|
||||
u8 f = m_flags[m_area.index(p)];
|
||||
// Ignore inexistent or checked nodes
|
||||
if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED3))
|
||||
continue;
|
||||
MapNode &n = m_data[m_area.index(p)];
|
||||
// Ignore non-liquid nodes
|
||||
if(content_liquid(n.d) == false)
|
||||
continue;
|
||||
|
||||
if(checked2_clear == false)
|
||||
{
|
||||
clearFlag(VOXELFLAG_CHECKED2);
|
||||
checked2_clear = true;
|
||||
}
|
||||
|
||||
checked2_clear = false;
|
||||
|
||||
s16 highest_y = -32768;
|
||||
int recur_count = 0;
|
||||
int pr = -1;
|
||||
|
||||
try
|
||||
{
|
||||
// 0-1ms @ recur_count <= 100
|
||||
//TimeTaker timer("getWaterPressure", g_irrlicht);
|
||||
pr = getWaterPressure(p, highest_y, recur_count);
|
||||
}
|
||||
catch(ProcessingLimitException &e)
|
||||
{
|
||||
//dstream<<"getWaterPressure ProcessingLimitException"<<std::endl;
|
||||
}
|
||||
|
||||
if(pr == -1)
|
||||
{
|
||||
assert(highest_y != -32768);
|
||||
|
||||
pr = highest_y - p.Y + 1;
|
||||
if(pr > 255)
|
||||
pr = 255;
|
||||
|
||||
/*dstream<<"WARNING: Pressure at ("
|
||||
<<p.X<<","<<p.Y<<","<<p.Z<<")"
|
||||
<<" = "<<pr
|
||||
//<<" and highest_y == -32768"
|
||||
<<std::endl;
|
||||
assert(highest_y != -32768);
|
||||
continue;*/
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
// 0ms
|
||||
//TimeTaker timer("spreadWaterPressure", g_irrlicht);
|
||||
spreadWaterPressure(p, pr, a, active_nodes, 0);
|
||||
}
|
||||
catch(ProcessingLimitException &e)
|
||||
{
|
||||
//dstream<<"getWaterPressure ProcessingLimitException"<<std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool VoxelManipulator::flowWater(v3s16 removed_pos,
|
||||
core::map<v3s16, u8> &active_nodes,
|
||||
int recursion_depth, bool debugprint,
|
||||
u32 stoptime)
|
||||
{
|
||||
v3s16 dirs[6] = {
|
||||
v3s16(0,1,0), // top
|
||||
v3s16(0,0,-1), // front
|
||||
v3s16(0,0,1), // back
|
||||
v3s16(-1,0,0), // left
|
||||
v3s16(1,0,0), // right
|
||||
v3s16(0,-1,0), // bottom
|
||||
};
|
||||
|
||||
recursion_depth++;
|
||||
|
||||
v3s16 p;
|
||||
bool from_ocean = false;
|
||||
|
||||
// Randomize horizontal order
|
||||
static s32 cs = 0;
|
||||
if(cs < 3)
|
||||
cs++;
|
||||
else
|
||||
cs = 0;
|
||||
s16 s1 = (cs & 1) ? 1 : -1;
|
||||
s16 s2 = (cs & 2) ? 1 : -1;
|
||||
//dstream<<"s1="<<s1<<", s2="<<s2<<std::endl;
|
||||
|
||||
{
|
||||
TimeTaker timer1("flowWater pre", &flowwater_pre_time);
|
||||
|
||||
// Load neighboring nodes
|
||||
emerge(VoxelArea(removed_pos - v3s16(1,1,1), removed_pos + v3s16(1,1,1)), 4);
|
||||
|
||||
// Ignore incorrect removed_pos
|
||||
{
|
||||
u8 f = m_flags[m_area.index(removed_pos)];
|
||||
// Ignore inexistent or checked node
|
||||
if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED))
|
||||
return false;
|
||||
MapNode &n = m_data[m_area.index(removed_pos)];
|
||||
// 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)];
|
||||
// Inexistent or checked nodes can't move
|
||||
if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED))
|
||||
continue;
|
||||
MapNode &n = m_data[m_area.index(p)];
|
||||
// Only liquid nodes can move
|
||||
if(content_liquid(n.d) == false)
|
||||
continue;
|
||||
// If block is at top, select it always
|
||||
if(i == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
// If block is at bottom, select it if it has enough pressure
|
||||
if(i == 5)
|
||||
{
|
||||
//if(n.pressure >= PRESERVE_WATER_VOLUME ? 3 : 2)
|
||||
if(n.pressure >= 3)
|
||||
break;
|
||||
continue;
|
||||
}
|
||||
// Else block is at some side. Select it if it has enough pressure
|
||||
//if(n.pressure >= PRESERVE_WATER_VOLUME ? 2 : 1)
|
||||
if(n.pressure >= 2)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// If there is nothing to move, return
|
||||
if(i==6)
|
||||
return false;
|
||||
|
||||
/*
|
||||
Move water and bubble
|
||||
*/
|
||||
|
||||
u8 m = m_data[m_area.index(p)].d;
|
||||
u8 f = m_flags[m_area.index(p)];
|
||||
|
||||
if(m == CONTENT_WATERSOURCE)
|
||||
from_ocean = true;
|
||||
|
||||
// Move air bubble if not taking water from ocean
|
||||
if(from_ocean == false)
|
||||
{
|
||||
m_data[m_area.index(p)].d = m_data[m_area.index(removed_pos)].d;
|
||||
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)].getLightBanksWithSource();
|
||||
|
||||
m_data[m_area.index(removed_pos)].d = m;
|
||||
m_flags[m_area.index(removed_pos)] = f;
|
||||
|
||||
m_data[m_area.index(removed_pos)].setLightBanks(light);
|
||||
|
||||
// Mark removed_pos checked
|
||||
m_flags[m_area.index(removed_pos)] |= VOXELFLAG_CHECKED;
|
||||
|
||||
// If block was dropped from surface, increase pressure
|
||||
if(i == 0 && m_data[m_area.index(removed_pos)].pressure == 1)
|
||||
{
|
||||
m_data[m_area.index(removed_pos)].pressure = 2;
|
||||
}
|
||||
|
||||
/*
|
||||
NOTE: This does not work as-is
|
||||
if(m == CONTENT_WATERSOURCE)
|
||||
{
|
||||
// If block was raised to surface, increase pressure of
|
||||
// source node
|
||||
if(i == 5 && m_data[m_area.index(p)].pressure == 1)
|
||||
{
|
||||
m_data[m_area.index(p)].pressure = 2;
|
||||
}
|
||||
}*/
|
||||
|
||||
/*if(debugprint)
|
||||
{
|
||||
dstream<<"VoxelManipulator::flowWater(): Moved bubble:"<<std::endl;
|
||||
print(dstream, VOXELPRINT_WATERPRESSURE);
|
||||
}*/
|
||||
|
||||
// Update pressure
|
||||
VoxelArea a;
|
||||
a.addPoint(p - v3s16(1,1,1));
|
||||
a.addPoint(p + v3s16(1,1,1));
|
||||
a.addPoint(removed_pos - v3s16(1,1,1));
|
||||
a.addPoint(removed_pos + v3s16(1,1,1));
|
||||
updateAreaWaterPressure(a, active_nodes);
|
||||
|
||||
/*if(debugprint)
|
||||
{
|
||||
dstream<<"VoxelManipulator::flowWater(): Pressure updated:"<<std::endl;
|
||||
print(dstream, VOXELPRINT_WATERPRESSURE);
|
||||
//std::cin.get();
|
||||
}*/
|
||||
|
||||
if(debugprint)
|
||||
{
|
||||
dstream<<"VoxelManipulator::flowWater(): step done:"<<std::endl;
|
||||
print(dstream, VOXELPRINT_WATERPRESSURE);
|
||||
//std::cin.get();
|
||||
}
|
||||
|
||||
}//timer1
|
||||
|
||||
//if(PRESERVE_WATER_VOLUME)
|
||||
if(from_ocean == false)
|
||||
{
|
||||
// Flow water to the newly created empty position
|
||||
/*flowWater(p, active_nodes, recursion_depth,
|
||||
debugprint, counter, counterlimit);*/
|
||||
flowWater(p, active_nodes, recursion_depth,
|
||||
debugprint, stoptime);
|
||||
}
|
||||
|
||||
if(stoptime != 0)
|
||||
{
|
||||
u32 timenow = getTimeMs();
|
||||
// Well, it is a bit hard to guess because we don't know the
|
||||
// start time...
|
||||
bool overflow = timenow < stoptime - 100000;
|
||||
if(timenow >= stoptime || overflow)
|
||||
{
|
||||
dstream<<"flowWater: stoptime reached"<<std::endl;
|
||||
throw ProcessingLimitException("flowWater stoptime reached");
|
||||
}
|
||||
}
|
||||
|
||||
find_again:
|
||||
|
||||
// Try flowing water to empty positions around removed_pos.
|
||||
// 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);
|
||||
|
||||
u8 f = m_flags[m_area.index(p)];
|
||||
// Water can't move to inexistent nodes
|
||||
if(f & VOXELFLAG_INEXISTENT)
|
||||
continue;
|
||||
MapNode &n = m_data[m_area.index(p)];
|
||||
// Water can only move to air
|
||||
if(liquid_replaces_content(n.d) == false)
|
||||
continue;
|
||||
|
||||
// Flow water to node
|
||||
bool moved =
|
||||
flowWater(p, active_nodes, recursion_depth,
|
||||
debugprint, stoptime);
|
||||
/*flowWater(p, active_nodes, recursion_depth,
|
||||
debugprint, counter, counterlimit);*/
|
||||
|
||||
if(moved)
|
||||
{
|
||||
// Search again from all neighbors
|
||||
goto find_again;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void VoxelManipulator::flowWater(
|
||||
core::map<v3s16, u8> &active_nodes,
|
||||
int recursion_depth, bool debugprint,
|
||||
u32 timelimit)
|
||||
{
|
||||
addarea_time = 0;
|
||||
emerge_time = 0;
|
||||
emerge_load_time = 0;
|
||||
clearflag_time = 0;
|
||||
updateareawaterpressure_time = 0;
|
||||
flowwater_pre_time = 0;
|
||||
|
||||
if(active_nodes.size() == 0)
|
||||
{
|
||||
dstream<<"flowWater: no active nodes"<<std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
//TimeTaker timer1("flowWater (active_nodes)", g_irrlicht);
|
||||
|
||||
//dstream<<"active_nodes.size() = "<<active_nodes.size()<<std::endl;
|
||||
|
||||
|
||||
u32 stoptime = 0;
|
||||
stoptime = getTimeMs() + timelimit;
|
||||
|
||||
// Count of handled active nodes
|
||||
u32 handled_count = 0;
|
||||
|
||||
try
|
||||
{
|
||||
|
||||
/*
|
||||
Take random one at first
|
||||
|
||||
This is randomized only at the first time so that all
|
||||
subsequent nodes will be taken at roughly the same position
|
||||
*/
|
||||
s32 k = 0;
|
||||
if(active_nodes.size() != 0)
|
||||
k = (s32)myrand() % (s32)active_nodes.size();
|
||||
|
||||
// Flow water to active nodes
|
||||
for(;;)
|
||||
//for(s32 h=0; h<1; h++)
|
||||
{
|
||||
if(active_nodes.size() == 0)
|
||||
break;
|
||||
|
||||
handled_count++;
|
||||
|
||||
// Clear check flags
|
||||
clearFlag(VOXELFLAG_CHECKED);
|
||||
|
||||
//dstream<<"Selecting a new active_node"<<std::endl;
|
||||
|
||||
#if 0
|
||||
// Take first one
|
||||
core::map<v3s16, u8>::Node
|
||||
*n = active_nodes.getIterator().getNode();
|
||||
#endif
|
||||
|
||||
#if 1
|
||||
|
||||
core::map<v3s16, u8>::Iterator
|
||||
i = active_nodes.getIterator().getNode();
|
||||
for(s32 j=0; j<k; j++)
|
||||
{
|
||||
i++;
|
||||
}
|
||||
core::map<v3s16, u8>::Node *n = i.getNode();
|
||||
|
||||
// Decrement index if less than 0.
|
||||
// This keeps us in existing indices always.
|
||||
if(k > 0)
|
||||
k--;
|
||||
#endif
|
||||
|
||||
v3s16 p = n->getKey();
|
||||
active_nodes.remove(p);
|
||||
flowWater(p, active_nodes, recursion_depth,
|
||||
debugprint, stoptime);
|
||||
}
|
||||
|
||||
}
|
||||
catch(ProcessingLimitException &e)
|
||||
{
|
||||
//dstream<<"getWaterPressure ProcessingLimitException"<<std::endl;
|
||||
}
|
||||
|
||||
/*v3s16 e = m_area.getExtent();
|
||||
s32 v = m_area.getVolume();
|
||||
dstream<<"flowWater (active): "
|
||||
<<"area ended up as "
|
||||
<<e.X<<"x"<<e.Y<<"x"<<e.Z<<" = "<<v
|
||||
<<", handled a_node count: "<<handled_count
|
||||
<<", active_nodes.size() = "<<active_nodes.size()
|
||||
<<std::endl;
|
||||
dstream<<"addarea_time: "<<addarea_time
|
||||
<<", emerge_time: "<<emerge_time
|
||||
<<", emerge_load_time: "<<emerge_load_time
|
||||
<<", clearflag_time: "<<clearflag_time
|
||||
<<", flowwater_pre_time: "<<flowwater_pre_time
|
||||
<<", updateareawaterpressure_time: "<<updateareawaterpressure_time
|
||||
<<std::endl;*/
|
||||
}
|
||||
#endif
|
||||
|
||||
//END
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue