1
0
mirror of https://github.com/moparisthebest/minetest synced 2024-12-23 16:08:51 -05:00

Made a proper queued thread to client for handling some block mesh updates. Also made client mutex-free to allow easier adding of new stuff.

This commit is contained in:
Perttu Ahola 2011-04-04 02:05:12 +03:00
parent e0f7bd4d57
commit 2f466726e6
7 changed files with 722 additions and 390 deletions

View File

@ -26,7 +26,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <sstream> #include <sstream>
#include "porting.h" #include "porting.h"
void * ClientUpdateThread::Thread() void * MeshUpdateThread::Thread()
{ {
ThreadStarted(); ThreadStarted();
@ -36,14 +36,28 @@ void * ClientUpdateThread::Thread()
while(getRun()) while(getRun())
{ {
//m_client->asyncStep(); QueuedMeshUpdate *q = m_queue_in.pop();
if(q == NULL)
{
sleep_ms(50);
continue;
}
//m_client->updateSomeExpiredMeshes(); scene::SMesh *mesh_new = NULL;
mesh_new = makeMapBlockMesh(q->data);
bool was = m_client->AsyncProcessData(); MeshUpdateResult r;
r.p = q->p;
r.mesh = mesh_new;
r.ack_block_to_server = q->ack_block_to_server;
if(was == false) /*dstream<<"MeshUpdateThread: Processed "
sleep_ms(10); <<"("<<q->p.X<<","<<q->p.Y<<","<<q->p.Z<<")"
<<std::endl;*/
m_queue_out.push_back(r);
delete q;
} }
END_DEBUG_EXCEPTION_HANDLER END_DEBUG_EXCEPTION_HANDLER
@ -55,7 +69,7 @@ Client::Client(
IrrlichtDevice *device, IrrlichtDevice *device,
const char *playername, const char *playername,
MapDrawControl &control): MapDrawControl &control):
m_thread(this), m_mesh_update_thread(),
m_env( m_env(
new ClientMap(this, control, new ClientMap(this, control,
device->getSceneManager()->getRootSceneNode(), device->getSceneManager()->getRootSceneNode(),
@ -67,7 +81,6 @@ Client::Client(
camera_position(0,0,0), camera_position(0,0,0),
camera_direction(0,0,1), camera_direction(0,0,1),
m_server_ser_ver(SER_FMT_VER_INVALID), m_server_ser_ver(SER_FMT_VER_INVALID),
m_step_dtime(0.0),
m_inventory_updated(false), m_inventory_updated(false),
m_time_of_day(0) m_time_of_day(0)
{ {
@ -77,19 +90,16 @@ Client::Client(
m_avg_rtt_timer = 0.0; m_avg_rtt_timer = 0.0;
m_playerpos_send_timer = 0.0; m_playerpos_send_timer = 0.0;
//m_fetchblock_mutex.Init(); //m_env_mutex.Init();
m_incoming_queue_mutex.Init(); //m_con_mutex.Init();
m_env_mutex.Init();
m_con_mutex.Init();
m_step_dtime_mutex.Init();
m_thread.Start(); m_mesh_update_thread.Start();
/* /*
Add local player Add local player
*/ */
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
Player *player = new LocalPlayer(); Player *player = new LocalPlayer();
@ -102,26 +112,26 @@ Client::Client(
Client::~Client() Client::~Client()
{ {
{ {
JMutexAutoLock conlock(m_con_mutex); //JMutexAutoLock conlock(m_con_mutex); //bulk comment-out
m_con.Disconnect(); m_con.Disconnect();
} }
m_thread.setRun(false); m_mesh_update_thread.setRun(false);
while(m_thread.IsRunning()) while(m_mesh_update_thread.IsRunning())
sleep_ms(100); sleep_ms(100);
} }
void Client::connect(Address address) void Client::connect(Address address)
{ {
DSTACK(__FUNCTION_NAME); DSTACK(__FUNCTION_NAME);
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
m_con.setTimeoutMs(0); m_con.setTimeoutMs(0);
m_con.Connect(address); m_con.Connect(address);
} }
bool Client::connectedAndInitialized() bool Client::connectedAndInitialized()
{ {
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
if(m_con.Connected() == false) if(m_con.Connected() == false)
return false; return false;
@ -152,7 +162,7 @@ void Client::step(float dtime)
{ {
//TimeTaker timer("m_con_mutex + m_con.RunTimeouts()", m_device); //TimeTaker timer("m_con_mutex + m_con.RunTimeouts()", m_device);
// 0ms // 0ms
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
m_con.RunTimeouts(dtime); m_con.RunTimeouts(dtime);
} }
@ -188,7 +198,7 @@ void Client::step(float dtime)
//counter = 180.0; //counter = 180.0;
counter = 60.0; counter = 60.0;
JMutexAutoLock lock(m_env_mutex); //JMutexAutoLock lock(m_env_mutex); //bulk comment-out
core::list<v3s16> deleted_blocks; core::list<v3s16> deleted_blocks;
@ -217,7 +227,7 @@ void Client::step(float dtime)
*/ */
// Env is locked so con can be locked. // Env is locked so con can be locked.
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
core::list<v3s16>::Iterator i = deleted_blocks.begin(); core::list<v3s16>::Iterator i = deleted_blocks.begin();
core::list<v3s16> sendlist; core::list<v3s16> sendlist;
@ -271,7 +281,7 @@ void Client::step(float dtime)
{ {
counter = 2.0; counter = 2.0;
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
Player *myplayer = m_env.getLocalPlayer(); Player *myplayer = m_env.getLocalPlayer();
assert(myplayer != NULL); assert(myplayer != NULL);
@ -299,7 +309,7 @@ void Client::step(float dtime)
{ {
// 0ms // 0ms
JMutexAutoLock lock(m_env_mutex); //JMutexAutoLock lock(m_env_mutex); //bulk comment-out
// Control local player (0ms) // Control local player (0ms)
LocalPlayer *player = m_env.getLocalPlayer(); LocalPlayer *player = m_env.getLocalPlayer();
@ -335,7 +345,7 @@ void Client::step(float dtime)
if(counter >= 10) if(counter >= 10)
{ {
counter = 0.0; counter = 0.0;
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
// connectedAndInitialized() is true, peer exists. // connectedAndInitialized() is true, peer exists.
con::Peer *peer = m_con.GetPeer(PEER_ID_SERVER); con::Peer *peer = m_con.GetPeer(PEER_ID_SERVER);
dstream<<DTIME<<"Client: avg_rtt="<<peer->avg_rtt<<std::endl; dstream<<DTIME<<"Client: avg_rtt="<<peer->avg_rtt<<std::endl;
@ -351,31 +361,50 @@ void Client::step(float dtime)
} }
} }
/*{ /*
JMutexAutoLock lock(m_step_dtime_mutex); Replace updated meshes
m_step_dtime += dtime; */
}*/
}
#if 0
float Client::asyncStep()
{
DSTACK(__FUNCTION_NAME);
//dstream<<"Client::asyncStep()"<<std::endl;
/*float dtime;
{ {
JMutexAutoLock lock1(m_step_dtime_mutex); //JMutexAutoLock lock(m_env_mutex); //bulk comment-out
if(m_step_dtime < 0.001)
return 0.0;
dtime = m_step_dtime;
m_step_dtime = 0.0;
}
return dtime;*/ //TimeTaker timer("** Processing mesh update result queue");
return 0.0; // 0ms
/*dstream<<"Mesh update result queue size is "
<<m_mesh_update_thread.m_queue_out.size()
<<std::endl;*/
while(m_mesh_update_thread.m_queue_out.size() > 0)
{
MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_front();
MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(r.p);
if(block)
{
block->replaceMesh(r.mesh);
}
if(r.ack_block_to_server)
{
/*
Acknowledge block
*/
/*
[0] u16 command
[2] u8 count
[3] v3s16 pos_0
[3+6] v3s16 pos_1
...
*/
u32 replysize = 2+1+6;
SharedBuffer<u8> reply(replysize);
writeU16(&reply[0], TOSERVER_GOTBLOCKS);
reply[2] = 1;
writeV3S16(&reply[3], r.p);
// Send as reliable
m_con.Send(PEER_ID_SERVER, 1, reply, true);
}
}
}
} }
#endif
// Virtual methods from con::PeerHandler // Virtual methods from con::PeerHandler
void Client::peerAdded(con::Peer *peer) void Client::peerAdded(con::Peer *peer)
@ -420,7 +449,7 @@ void Client::Receive()
u32 datasize; u32 datasize;
{ {
//TimeTaker t1("con mutex and receive", m_device); //TimeTaker t1("con mutex and receive", m_device);
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
datasize = m_con.Receive(sender_peer_id, *data, data_maxsize); datasize = m_con.Receive(sender_peer_id, *data, data_maxsize);
} }
//TimeTaker t1("ProcessData", m_device); //TimeTaker t1("ProcessData", m_device);
@ -460,7 +489,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
con::Peer *peer; con::Peer *peer;
{ {
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
// All data is coming from the server // All data is coming from the server
// PeerNotFoundException is handled by caller. // PeerNotFoundException is handled by caller.
peer = m_con.GetPeer(PEER_ID_SERVER); peer = m_con.GetPeer(PEER_ID_SERVER);
@ -499,7 +528,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
v3f playerpos_f = intToFloat(playerpos_s16, BS) - v3f(0, BS/2, 0); v3f playerpos_f = intToFloat(playerpos_s16, BS) - v3f(0, BS/2, 0);
{ //envlock { //envlock
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
// Set player position // Set player position
Player *player = m_env.getLocalPlayer(); Player *player = m_env.getLocalPlayer();
@ -569,13 +598,138 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
addNode(p, n); addNode(p, n);
} }
else if(command == TOCLIENT_BLOCKDATA)
{
// Ignore too small packet
if(datasize < 8)
return;
v3s16 p;
p.X = readS16(&data[2]);
p.Y = readS16(&data[4]);
p.Z = readS16(&data[6]);
/*dout_client<<DTIME<<"Client: Thread: BLOCKDATA for ("
<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
/*dstream<<DTIME<<"Client: Thread: BLOCKDATA for ("
<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
std::string datastring((char*)&data[8], datasize-8);
std::istringstream istr(datastring, std::ios_base::binary);
MapSector *sector;
MapBlock *block;
{ //envlock
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
v2s16 p2d(p.X, p.Z);
sector = m_env.getMap().emergeSector(p2d);
v2s16 sp = sector->getPos();
if(sp != p2d)
{
dstream<<"ERROR: Got sector with getPos()="
<<"("<<sp.X<<","<<sp.Y<<"), tried to get"
<<"("<<p2d.X<<","<<p2d.Y<<")"<<std::endl;
}
assert(sp == p2d);
//assert(sector->getPos() == p2d);
//TimeTaker timer("MapBlock deSerialize");
// 0ms
try{
block = sector->getBlockNoCreate(p.Y);
/*
Update an existing block
*/
//dstream<<"Updating"<<std::endl;
block->deSerialize(istr, ser_version);
//block->setChangedFlag();
}
catch(InvalidPositionException &e)
{
/*
Create a new block
*/
//dstream<<"Creating new"<<std::endl;
block = new MapBlock(&m_env.getMap(), p);
block->deSerialize(istr, ser_version);
sector->insertBlock(block);
//block->setChangedFlag();
//DEBUG
/*NodeMod mod;
mod.type = NODEMOD_CHANGECONTENT;
mod.param = CONTENT_MESE;
block->setTempMod(v3s16(8,10,8), mod);
block->setTempMod(v3s16(8,9,8), mod);
block->setTempMod(v3s16(8,8,8), mod);
block->setTempMod(v3s16(8,7,8), mod);
block->setTempMod(v3s16(8,6,8), mod);*/
#if 0
/*
Add some coulds
Well, this is a dumb way to do it, they should just
be drawn as separate objects. But the looks of them
can be tested this way.
*/
if(p.Y == 3)
{
NodeMod mod;
mod.type = NODEMOD_CHANGECONTENT;
mod.param = CONTENT_CLOUD;
v3s16 p2;
p2.Y = 8;
for(p2.X=3; p2.X<=13; p2.X++)
for(p2.Z=3; p2.Z<=13; p2.Z++)
{
block->setTempMod(p2, mod);
}
}
#endif
}
} //envlock
#if 0
/*
Acknowledge block
*/
/*
[0] u16 command
[2] u8 count
[3] v3s16 pos_0
[3+6] v3s16 pos_1
...
*/
u32 replysize = 2+1+6;
SharedBuffer<u8> reply(replysize);
writeU16(&reply[0], TOSERVER_GOTBLOCKS);
reply[2] = 1;
writeV3S16(&reply[3], p);
// Send as reliable
m_con.Send(PEER_ID_SERVER, 1, reply, true);
#endif
/*
Update Mesh of this block and blocks at x-, y- and z-.
Environment should not be locked as it interlocks with the
main thread, from which is will want to retrieve textures.
*/
//m_env.getClientMap().updateMeshes(block->getPos(), getDayNightRatio());
addUpdateMeshTaskWithEdge(p, true);
}
else if(command == TOCLIENT_PLAYERPOS) else if(command == TOCLIENT_PLAYERPOS)
{ {
dstream<<"WARNING: Received deprecated TOCLIENT_PLAYERPOS" dstream<<"WARNING: Received deprecated TOCLIENT_PLAYERPOS"
<<std::endl; <<std::endl;
/*u16 our_peer_id; /*u16 our_peer_id;
{ {
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
our_peer_id = m_con.GetPeerID(); our_peer_id = m_con.GetPeerID();
} }
// Cancel if we don't have a peer id // Cancel if we don't have a peer id
@ -587,7 +741,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
}*/ }*/
{ //envlock { //envlock
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
u32 player_size = 2+12+12+4+4; u32 player_size = 2+12+12+4+4;
@ -641,7 +795,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
{ {
u16 our_peer_id; u16 our_peer_id;
{ {
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
our_peer_id = m_con.GetPeerID(); our_peer_id = m_con.GetPeerID();
} }
// Cancel if we don't have a peer id // Cancel if we don't have a peer id
@ -655,7 +809,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
//dstream<<DTIME<<"Client: Server reports players:"<<std::endl; //dstream<<DTIME<<"Client: Server reports players:"<<std::endl;
{ //envlock { //envlock
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
u32 item_size = 2+PLAYERNAME_SIZE; u32 item_size = 2+PLAYERNAME_SIZE;
u32 player_count = (datasize-2) / item_size; u32 player_count = (datasize-2) / item_size;
@ -754,7 +908,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
//dstream<<"Client received TOCLIENT_SECTORMETA"<<std::endl; //dstream<<"Client received TOCLIENT_SECTORMETA"<<std::endl;
{ //envlock { //envlock
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
std::string datastring((char*)&data[2], datasize-2); std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary); std::istringstream is(datastring, std::ios_base::binary);
@ -788,7 +942,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
{ //envlock { //envlock
//TimeTaker t2("mutex locking", m_device); //TimeTaker t2("mutex locking", m_device);
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
//t2.stop(); //t2.stop();
//TimeTaker t3("istringstream init", m_device); //TimeTaker t3("istringstream init", m_device);
@ -823,7 +977,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
{ //envlock { //envlock
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
u8 buf[12]; u8 buf[12];
@ -981,7 +1135,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
u16 time = readU16(&data[2]); u16 time = readU16(&data[2]);
time = time % 24000; time = time % 24000;
m_time_of_day.set(time); m_time_of_day = time;
//dstream<<"Client: time="<<time<<std::endl; //dstream<<"Client: time="<<time<<std::endl;
/* /*
@ -992,9 +1146,9 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
12000 = midday 12000 = midday
*/ */
{ {
u32 dr = time_to_daynight_ratio(m_time_of_day.get()); u32 dr = time_to_daynight_ratio(m_time_of_day);
dstream<<"Client: time_of_day="<<m_time_of_day.get() dstream<<"Client: time_of_day="<<m_time_of_day
<<", dr="<<dr <<", dr="<<dr
<<std::endl; <<std::endl;
@ -1070,7 +1224,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
u16 id = readU16((u8*)buf); u16 id = readU16((u8*)buf);
// Remove it // Remove it
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
m_env.removeActiveObject(id); m_env.removeActiveObject(id);
} }
} }
@ -1087,7 +1241,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
std::string data = deSerializeLongString(is); std::string data = deSerializeLongString(is);
// Add it // Add it
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
m_env.addActiveObject(id, type, data); m_env.addActiveObject(id, type, data);
} }
} }
@ -1130,12 +1284,18 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
} }
// Pass on to the environment // Pass on to the environment
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
m_env.processActiveObjectMessage(id, message); m_env.processActiveObjectMessage(id, message);
} }
} }
} }
} }
else
{
dout_client<<DTIME<<"WARNING: Client: Ignoring unknown command "
<<command<<std::endl;
}
#if 0
// Default to queueing it (for slow commands) // Default to queueing it (for slow commands)
else else
{ {
@ -1144,8 +1304,10 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
IncomingPacket packet(data, datasize); IncomingPacket packet(data, datasize);
m_incoming_queue.push_back(packet); m_incoming_queue.push_back(packet);
} }
#endif
} }
#if 0
/* /*
Returns true if there was something in queue Returns true if there was something in queue
*/ */
@ -1158,7 +1320,7 @@ bool Client::AsyncProcessPacket()
con::Peer *peer; con::Peer *peer;
{ {
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
// All data is coming from the server // All data is coming from the server
peer = m_con.GetPeer(PEER_ID_SERVER); peer = m_con.GetPeer(PEER_ID_SERVER);
} }
@ -1192,7 +1354,6 @@ bool Client::AsyncProcessPacket()
/*dout_client<<DTIME<<"Client: Thread: BLOCKDATA for (" /*dout_client<<DTIME<<"Client: Thread: BLOCKDATA for ("
<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/ <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
/*dstream<<DTIME<<"Client: Thread: BLOCKDATA for (" /*dstream<<DTIME<<"Client: Thread: BLOCKDATA for ("
<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/ <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
@ -1203,7 +1364,7 @@ bool Client::AsyncProcessPacket()
MapBlock *block; MapBlock *block;
{ //envlock { //envlock
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
v2s16 p2d(p.X, p.Z); v2s16 p2d(p.X, p.Z);
sector = m_env.getMap().emergeSector(p2d); sector = m_env.getMap().emergeSector(p2d);
@ -1219,6 +1380,9 @@ bool Client::AsyncProcessPacket()
assert(sp == p2d); assert(sp == p2d);
//assert(sector->getPos() == p2d); //assert(sector->getPos() == p2d);
//TimeTaker timer("MapBlock deSerialize");
// 0ms
try{ try{
block = sector->getBlockNoCreate(p.Y); block = sector->getBlockNoCreate(p.Y);
/* /*
@ -1248,13 +1412,14 @@ bool Client::AsyncProcessPacket()
block->setTempMod(v3s16(8,8,8), mod); block->setTempMod(v3s16(8,8,8), mod);
block->setTempMod(v3s16(8,7,8), mod); block->setTempMod(v3s16(8,7,8), mod);
block->setTempMod(v3s16(8,6,8), mod);*/ block->setTempMod(v3s16(8,6,8), mod);*/
#if 0
/* /*
Add some coulds Add some coulds
Well, this is a dumb way to do it, they should just Well, this is a dumb way to do it, they should just
be drawn as separate objects. be drawn as separate objects. But the looks of them
can be tested this way.
*/ */
/*if(p.Y == 3) if(p.Y == 3)
{ {
NodeMod mod; NodeMod mod;
mod.type = NODEMOD_CHANGECONTENT; mod.type = NODEMOD_CHANGECONTENT;
@ -1266,7 +1431,8 @@ bool Client::AsyncProcessPacket()
{ {
block->setTempMod(p2, mod); block->setTempMod(p2, mod);
} }
}*/ }
#endif
} }
} //envlock } //envlock
@ -1294,7 +1460,20 @@ bool Client::AsyncProcessPacket()
main thread, from which is will want to retrieve textures. main thread, from which is will want to retrieve textures.
*/ */
m_env.getClientMap().updateMeshes(block->getPos(), getDayNightRatio()); //m_env.getClientMap().updateMeshes(block->getPos(), getDayNightRatio());
MeshMakeData data;
{
//TimeTaker timer("data fill");
// 0ms
data.fill(getDayNightRatio(), block);
}
{
TimeTaker timer("make mesh");
scene::SMesh *mesh_new = NULL;
mesh_new = makeMapBlockMesh(&data);
block->replaceMesh(mesh_new);
}
} }
else else
{ {
@ -1323,13 +1502,15 @@ bool Client::AsyncProcessData()
} }
return false; return false;
} }
#endif
void Client::Send(u16 channelnum, SharedBuffer<u8> data, bool reliable) void Client::Send(u16 channelnum, SharedBuffer<u8> data, bool reliable)
{ {
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
m_con.Send(PEER_ID_SERVER, channelnum, data, reliable); m_con.Send(PEER_ID_SERVER, channelnum, data, reliable);
} }
#if 0
IncomingPacket Client::getPacket() IncomingPacket Client::getPacket()
{ {
JMutexAutoLock lock(m_incoming_queue_mutex); JMutexAutoLock lock(m_incoming_queue_mutex);
@ -1349,6 +1530,7 @@ IncomingPacket Client::getPacket()
m_incoming_queue.erase(i); m_incoming_queue.erase(i);
return packet; return packet;
} }
#endif
void Client::groundAction(u8 action, v3s16 nodepos_undersurface, void Client::groundAction(u8 action, v3s16 nodepos_undersurface,
v3s16 nodepos_oversurface, u16 item) v3s16 nodepos_oversurface, u16 item)
@ -1496,7 +1678,7 @@ void Client::sendChatMessage(const std::wstring &message)
void Client::sendPlayerPos() void Client::sendPlayerPos()
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
Player *myplayer = m_env.getLocalPlayer(); Player *myplayer = m_env.getLocalPlayer();
if(myplayer == NULL) if(myplayer == NULL)
@ -1504,7 +1686,7 @@ void Client::sendPlayerPos()
u16 our_peer_id; u16 our_peer_id;
{ {
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
our_peer_id = m_con.GetPeerID(); our_peer_id = m_con.GetPeerID();
} }
@ -1543,7 +1725,7 @@ void Client::sendPlayerPos()
void Client::removeNode(v3s16 p) void Client::removeNode(v3s16 p)
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
core::map<v3s16, MapBlock*> modified_blocks; core::map<v3s16, MapBlock*> modified_blocks;
@ -1567,7 +1749,7 @@ void Client::removeNode(v3s16 p)
void Client::addNode(v3s16 p, MapNode n) void Client::addNode(v3s16 p, MapNode n)
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
TimeTaker timer1("Client::addNode()"); TimeTaker timer1("Client::addNode()");
@ -1601,19 +1783,19 @@ void Client::updateCamera(v3f pos, v3f dir)
MapNode Client::getNode(v3s16 p) MapNode Client::getNode(v3s16 p)
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
return m_env.getMap().getNode(p); return m_env.getMap().getNode(p);
} }
NodeMetadata* Client::getNodeMetadataClone(v3s16 p) NodeMetadata* Client::getNodeMetadataClone(v3s16 p)
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
return m_env.getMap().getNodeMetadataClone(p); return m_env.getMap().getNodeMetadataClone(p);
} }
v3f Client::getPlayerPosition() v3f Client::getPlayerPosition()
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
LocalPlayer *player = m_env.getLocalPlayer(); LocalPlayer *player = m_env.getLocalPlayer();
assert(player != NULL); assert(player != NULL);
return player->getPosition(); return player->getPosition();
@ -1621,7 +1803,7 @@ v3f Client::getPlayerPosition()
void Client::setPlayerControl(PlayerControl &control) void Client::setPlayerControl(PlayerControl &control)
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
LocalPlayer *player = m_env.getLocalPlayer(); LocalPlayer *player = m_env.getLocalPlayer();
assert(player != NULL); assert(player != NULL);
player->control = control; player->control = control;
@ -1632,7 +1814,7 @@ void Client::setPlayerControl(PlayerControl &control)
bool Client::getLocalInventoryUpdated() bool Client::getLocalInventoryUpdated()
{ {
// m_inventory_updated is behind envlock // m_inventory_updated is behind envlock
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
bool updated = m_inventory_updated; bool updated = m_inventory_updated;
m_inventory_updated = false; m_inventory_updated = false;
return updated; return updated;
@ -1641,7 +1823,7 @@ bool Client::getLocalInventoryUpdated()
// Copies the inventory of the local player to parameter // Copies the inventory of the local player to parameter
void Client::getLocalInventory(Inventory &dst) void Client::getLocalInventory(Inventory &dst)
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
Player *player = m_env.getLocalPlayer(); Player *player = m_env.getLocalPlayer();
assert(player != NULL); assert(player != NULL);
dst = player->inventory; dst = player->inventory;
@ -1653,7 +1835,7 @@ MapBlockObject * Client::getSelectedObject(
core::line3d<f32> shootline_on_map core::line3d<f32> shootline_on_map
) )
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
core::array<DistanceSortedObject> objects; core::array<DistanceSortedObject> objects;
@ -1715,12 +1897,12 @@ MapBlockObject * Client::getSelectedObject(
void Client::printDebugInfo(std::ostream &os) void Client::printDebugInfo(std::ostream &os)
{ {
//JMutexAutoLock lock1(m_fetchblock_mutex); //JMutexAutoLock lock1(m_fetchblock_mutex);
JMutexAutoLock lock2(m_incoming_queue_mutex); /*JMutexAutoLock lock2(m_incoming_queue_mutex);
os<<"m_incoming_queue.getSize()="<<m_incoming_queue.getSize() os<<"m_incoming_queue.getSize()="<<m_incoming_queue.getSize()
//<<", m_fetchblock_history.size()="<<m_fetchblock_history.size() //<<", m_fetchblock_history.size()="<<m_fetchblock_history.size()
//<<", m_opt_not_found_history.size()="<<m_opt_not_found_history.size() //<<", m_opt_not_found_history.size()="<<m_opt_not_found_history.size()
<<std::endl; <<std::endl;*/
} }
/*s32 Client::getDayNightIndex() /*s32 Client::getDayNightIndex()
@ -1731,63 +1913,87 @@ void Client::printDebugInfo(std::ostream &os)
u32 Client::getDayNightRatio() u32 Client::getDayNightRatio()
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
return m_env.getDayNightRatio(); return m_env.getDayNightRatio();
} }
/*void Client::updateSomeExpiredMeshes() void Client::addUpdateMeshTask(v3s16 p, bool ack_to_server)
{ {
TimeTaker timer("updateSomeExpiredMeshes()", g_device); /*dstream<<"Client::addUpdateMeshTask(): "
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<std::endl;*/
MapBlock *b = m_env.getMap().getBlockNoCreateNoEx(p);
if(b == NULL)
return;
/*
Create a task to update the mesh of the block
*/
MeshMakeData *data = new MeshMakeData;
Player *player;
{ {
JMutexAutoLock envlock(m_env_mutex); //TimeTaker timer("data fill");
player = m_env.getLocalPlayer(); // 0ms
data->fill(getDayNightRatio(), b);
} }
u32 daynight_ratio = getDayNightRatio(); // Debug wait
//while(m_mesh_update_thread.m_queue_in.size() > 0) sleep_ms(10);
v3f playerpos = player->getPosition(); // Add task to queue
v3f playerspeed = player->getSpeed(); m_mesh_update_thread.m_queue_in.addBlock(p, data, ack_to_server);
v3s16 center_nodepos = floatToInt(playerpos, BS); /*dstream<<"Mesh update input queue size is "
v3s16 center = getNodeBlockPos(center_nodepos); <<m_mesh_update_thread.m_queue_in.size()
<<std::endl;*/
u32 counter = 0; #if 0
// Temporary test: make mesh directly in here
s16 d_max = 5;
for(s16 d = 0; d <= d_max; d++)
{ {
core::list<v3s16> list; //TimeTaker timer("make mesh");
getFacePositions(list, d); // 10ms
scene::SMesh *mesh_new = NULL;
core::list<v3s16>::Iterator li; mesh_new = makeMapBlockMesh(data);
for(li=list.begin(); li!=list.end(); li++) b->replaceMesh(mesh_new);
{ delete data;
v3s16 p = *li + center;
MapBlock *block = NULL;
try
{
//JMutexAutoLock envlock(m_env_mutex);
block = m_env.getMap().getBlockNoCreate(p);
}
catch(InvalidPositionException &e)
{
}
if(block == NULL)
continue;
if(block->getMeshExpired() == false)
continue;
block->updateMesh(daynight_ratio);
counter++;
if(counter >= 5)
return;
}
} }
}*/ #endif
b->setMeshExpired(false);
}
void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server)
{
/*{
v3s16 p = blockpos;
dstream<<"Client::addUpdateMeshTaskWithEdge(): "
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<std::endl;
}*/
try{
v3s16 p = blockpos + v3s16(0,0,0);
//MapBlock *b = m_env.getMap().getBlockNoCreate(p);
addUpdateMeshTask(p, ack_to_server);
}
catch(InvalidPositionException &e){}
// Leading edge
try{
v3s16 p = blockpos + v3s16(-1,0,0);
addUpdateMeshTask(p);
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,-1,0);
addUpdateMeshTask(p);
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,0,-1);
addUpdateMeshTask(p);
}
catch(InvalidPositionException &e){}
}

View File

@ -37,23 +37,144 @@ public:
{} {}
}; };
class Client; struct QueuedMeshUpdate
class ClientUpdateThread : public SimpleThread
{ {
Client *m_client; v3s16 p;
MeshMakeData *data;
bool ack_block_to_server;
QueuedMeshUpdate():
p(-1337,-1337,-1337),
data(NULL),
ack_block_to_server(false)
{
}
~QueuedMeshUpdate()
{
if(data)
delete data;
}
};
/*
A thread-safe queue of mesh update tasks
*/
class MeshUpdateQueue
{
public:
MeshUpdateQueue()
{
m_mutex.Init();
}
~MeshUpdateQueue()
{
JMutexAutoLock lock(m_mutex);
core::list<QueuedMeshUpdate*>::Iterator i;
for(i=m_queue.begin(); i!=m_queue.end(); i++)
{
QueuedMeshUpdate *q = *i;
delete q;
}
}
/*
peer_id=0 adds with nobody to send to
*/
void addBlock(v3s16 p, MeshMakeData *data, bool ack_block_to_server)
{
DSTACK(__FUNCTION_NAME);
assert(data);
JMutexAutoLock lock(m_mutex);
/*
Find if block is already in queue.
If it is, update the data and quit.
*/
core::list<QueuedMeshUpdate*>::Iterator i;
for(i=m_queue.begin(); i!=m_queue.end(); i++)
{
QueuedMeshUpdate *q = *i;
if(q->p == p)
{
if(q->data)
delete q->data;
q->data = data;
if(ack_block_to_server)
q->ack_block_to_server = true;
return;
}
}
/*
Add the block
*/
QueuedMeshUpdate *q = new QueuedMeshUpdate;
q->p = p;
q->data = data;
q->ack_block_to_server = ack_block_to_server;
m_queue.push_back(q);
}
// Returned pointer must be deleted
// Returns NULL if queue is empty
QueuedMeshUpdate * pop()
{
JMutexAutoLock lock(m_mutex);
core::list<QueuedMeshUpdate*>::Iterator i = m_queue.begin();
if(i == m_queue.end())
return NULL;
QueuedMeshUpdate *q = *i;
m_queue.erase(i);
return q;
}
u32 size()
{
JMutexAutoLock lock(m_mutex);
return m_queue.size();
}
private:
core::list<QueuedMeshUpdate*> m_queue;
JMutex m_mutex;
};
struct MeshUpdateResult
{
v3s16 p;
scene::SMesh *mesh;
bool ack_block_to_server;
MeshUpdateResult():
p(-1338,-1338,-1338),
mesh(NULL),
ack_block_to_server(false)
{
}
};
class MeshUpdateThread : public SimpleThread
{
public: public:
ClientUpdateThread(Client *client): MeshUpdateThread()
SimpleThread(),
m_client(client)
{ {
} }
void * Thread(); void * Thread();
MeshUpdateQueue m_queue_in;
MutexedQueue<MeshUpdateResult> m_queue_out;
}; };
#if 0
struct IncomingPacket struct IncomingPacket
{ {
IncomingPacket() IncomingPacket()
@ -101,13 +222,15 @@ struct IncomingPacket
u32 m_datalen; u32 m_datalen;
s32 *m_refcount; s32 *m_refcount;
}; };
#endif
class Client : public con::PeerHandler class Client : public con::PeerHandler
{ {
public: public:
/* /*
NOTE: Every public method should be thread-safe NOTE: Nothing is thread-safe here.
*/ */
Client( Client(
IrrlichtDevice *device, IrrlichtDevice *device,
const char *playername, const char *playername,
@ -147,7 +270,7 @@ public:
void Send(u16 channelnum, SharedBuffer<u8> data, bool reliable); void Send(u16 channelnum, SharedBuffer<u8> data, bool reliable);
// Pops out a packet from the packet queue // Pops out a packet from the packet queue
IncomingPacket getPacket(); //IncomingPacket getPacket();
void groundAction(u8 action, v3s16 nodepos_undersurface, void groundAction(u8 action, v3s16 nodepos_undersurface,
v3s16 nodepos_oversurface, u16 item); v3s16 nodepos_oversurface, u16 item);
@ -196,7 +319,7 @@ public:
void setTempMod(v3s16 p, NodeMod mod) void setTempMod(v3s16 p, NodeMod mod)
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
assert(m_env.getMap().mapType() == MAPTYPE_CLIENT); assert(m_env.getMap().mapType() == MAPTYPE_CLIENT);
core::map<v3s16, MapBlock*> affected_blocks; core::map<v3s16, MapBlock*> affected_blocks;
@ -212,7 +335,7 @@ public:
} }
void clearTempMod(v3s16 p) void clearTempMod(v3s16 p)
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
assert(m_env.getMap().mapType() == MAPTYPE_CLIENT); assert(m_env.getMap().mapType() == MAPTYPE_CLIENT);
core::map<v3s16, MapBlock*> affected_blocks; core::map<v3s16, MapBlock*> affected_blocks;
@ -229,7 +352,7 @@ public:
float getAvgRtt() float getAvgRtt()
{ {
JMutexAutoLock lock(m_con_mutex); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
con::Peer *peer = m_con.GetPeerNoEx(PEER_ID_SERVER); con::Peer *peer = m_con.GetPeerNoEx(PEER_ID_SERVER);
if(peer == NULL) if(peer == NULL)
return 0.0; return 0.0;
@ -246,7 +369,7 @@ public:
void addChatMessage(const std::wstring &message) void addChatMessage(const std::wstring &message)
{ {
JMutexAutoLock envlock(m_env_mutex); //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
LocalPlayer *player = m_env.getLocalPlayer(); LocalPlayer *player = m_env.getLocalPlayer();
assert(player != NULL); assert(player != NULL);
std::wstring name = narrow_to_wide(player->getName()); std::wstring name = narrow_to_wide(player->getName());
@ -256,6 +379,13 @@ public:
u64 getMapSeed(){ return m_map_seed; } u64 getMapSeed(){ return m_map_seed; }
/*
These are not thread-safe
*/
void addUpdateMeshTask(v3s16 blockpos, bool ack_to_server=false);
// Including blocks at appropriate edges
void addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server=false);
private: private:
// Virtual methods from con::PeerHandler // Virtual methods from con::PeerHandler
@ -275,19 +405,11 @@ private:
float m_avg_rtt_timer; float m_avg_rtt_timer;
float m_playerpos_send_timer; float m_playerpos_send_timer;
ClientUpdateThread m_thread; MeshUpdateThread m_mesh_update_thread;
// NOTE: If connection and environment are both to be locked,
// environment shall be locked first.
ClientEnvironment m_env; ClientEnvironment m_env;
JMutex m_env_mutex;
con::Connection m_con; con::Connection m_con;
JMutex m_con_mutex;
core::list<IncomingPacket> m_incoming_queue;
JMutex m_incoming_queue_mutex;
IrrlichtDevice *m_device; IrrlichtDevice *m_device;
@ -297,9 +419,6 @@ private:
// Server serialization version // Server serialization version
u8 m_server_ser_ver; u8 m_server_ser_ver;
float m_step_dtime;
JMutex m_step_dtime_mutex;
// This is behind m_env_mutex. // This is behind m_env_mutex.
bool m_inventory_updated; bool m_inventory_updated;
@ -308,7 +427,7 @@ private:
PacketCounter m_packetcounter; PacketCounter m_packetcounter;
// Received from the server. 0-23999 // Received from the server. 0-23999
MutexedVariable<u32> m_time_of_day; u32 m_time_of_day;
// 0 <= m_daynight_i < DAYNIGHT_CACHE_COUNT // 0 <= m_daynight_i < DAYNIGHT_CACHE_COUNT
//s32 m_daynight_i; //s32 m_daynight_i;

View File

@ -482,8 +482,8 @@ Inventory local_inventory;
u16 g_selected_item = 0; u16 g_selected_item = 0;
bool g_show_map_plot = false; /*bool g_show_map_plot = false;
bool g_refresh_map_plot = false; bool g_refresh_map_plot = false;*/
/* /*
Debug streams Debug streams
@ -601,7 +601,7 @@ public:
if(event.KeyInput.PressedDown) if(event.KeyInput.PressedDown)
{ {
//dstream<<"Pressed key: "<<(char)event.KeyInput.Key<<std::endl; //dstream<<"Pressed key: "<<(char)event.KeyInput.Key<<std::endl;
if(g_show_map_plot) /*if(g_show_map_plot)
{ {
if(event.KeyInput.Key == irr::KEY_ESCAPE if(event.KeyInput.Key == irr::KEY_ESCAPE
|| event.KeyInput.Key == irr::KEY_KEY_M) || event.KeyInput.Key == irr::KEY_KEY_M)
@ -609,7 +609,7 @@ public:
g_show_map_plot = false; g_show_map_plot = false;
} }
return true; return true;
} }*/
/* /*
Launch menus Launch menus
@ -685,13 +685,13 @@ public:
} }
// Map plot // Map plot
if(event.KeyInput.Key == irr::KEY_KEY_M) /*if(event.KeyInput.Key == irr::KEY_KEY_M)
{ {
dstream<<"Map plot requested"<<std::endl; dstream<<"Map plot requested"<<std::endl;
g_show_map_plot = !g_show_map_plot; g_show_map_plot = !g_show_map_plot;
if(g_show_map_plot) if(g_show_map_plot)
g_refresh_map_plot = true; g_refresh_map_plot = true;
} }*/
} }
} }
@ -2282,7 +2282,7 @@ int main(int argc, char *argv[])
//std::cout<<"busytime_u32="<<busytime_u32<<std::endl; //std::cout<<"busytime_u32="<<busytime_u32<<std::endl;
// Absolutelu necessary for wine! // Necessary for device->getTimer()->getTime()
device->run(); device->run();
/* /*
@ -2306,7 +2306,7 @@ int main(int argc, char *argv[])
} }
} }
// Absolutelu necessary for wine! // Necessary for device->getTimer()->getTime()
device->run(); device->run();
/* /*

View File

@ -5335,7 +5335,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
*/ */
int time1 = time(0); int time1 = time(0);
u32 daynight_ratio = m_client->getDayNightRatio(); //u32 daynight_ratio = m_client->getDayNightRatio();
m_camera_mutex.Lock(); m_camera_mutex.Lock();
v3f camera_position = m_camera_position; v3f camera_position = m_camera_position;
@ -5438,7 +5438,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
continue; continue;
} }
// This is ugly // This is ugly (spherical distance limit?)
/*if(m_control.range_all == false && /*if(m_control.range_all == false &&
d - 0.5*BS*MAP_BLOCKSIZE > range) d - 0.5*BS*MAP_BLOCKSIZE > range)
continue;*/ continue;*/
@ -5446,6 +5446,9 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
#if 1 #if 1
/* /*
Update expired mesh (used for day/night change) Update expired mesh (used for day/night change)
It doesn't work exactly like it should now with the
tasked mesh update but whatever.
*/ */
bool mesh_expired = false; bool mesh_expired = false;
@ -5482,28 +5485,12 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
mesh_update_count++; mesh_update_count++;
// Mesh has been expired: generate new mesh // Mesh has been expired: generate new mesh
block->updateMesh(daynight_ratio); //block->updateMesh(daynight_ratio);
//m_client->addUpdateMeshTask(block); m_client->addUpdateMeshTask(block->getPos());
mesh_expired = false; mesh_expired = false;
} }
/*
Don't draw an expired mesh that is far away
*/
/*if(mesh_expired && d >= faraway)
//if(mesh_expired)
{
// Instead, delete it
JMutexAutoLock lock(block->mesh_mutex);
if(block->mesh)
{
block->mesh->drop();
block->mesh = NULL;
}
// And continue to next block
continue;
}*/
#endif #endif
/* /*
Draw the faces of the block Draw the faces of the block

View File

@ -24,112 +24,61 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "light.h" #include "light.h"
#include <sstream> #include <sstream>
void MeshMakeData::fill(u32 daynight_ratio, MapBlock *block)
/*
MapBlock
*/
MapBlock::MapBlock(NodeContainer *parent, v3s16 pos, bool dummy):
m_parent(parent),
m_pos(pos),
changed(true),
is_underground(false),
m_lighting_expired(true),
m_day_night_differs(false),
//m_not_fully_generated(false),
m_objects(this)
{ {
data = NULL; m_daynight_ratio = daynight_ratio;
if(dummy == false) m_blockpos = block->getPos();
reallocate();
m_spawn_timer = -10000; v3s16 blockpos_nodes = m_blockpos*MAP_BLOCKSIZE;
#ifndef SERVER /*
m_mesh_expired = false; There is no harm not copying the TempMods of the neighbors
mesh_mutex.Init(); because they are already copied to this block
mesh = NULL; */
m_temp_mods_mutex.Init(); m_temp_mods.clear();
#endif 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)));
MapBlock::~MapBlock()
{
#ifndef SERVER
{ {
JMutexAutoLock lock(mesh_mutex); //TimeTaker timer("copy central block data");
// 0ms
if(mesh) // 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++)
{ {
mesh->drop(); const v3s16 &dir = g_6dirs[i];
mesh = NULL; v3s16 bp = m_blockpos + dir;
MapBlock *b = map->getBlockNoCreateNoEx(bp);
if(b)
b->copyTo(m_vmanip);
} }
} }
#endif
if(data)
delete[] data;
}
bool MapBlock::isValidPositionParent(v3s16 p)
{
if(isValidPosition(p))
{
return true;
}
else{
return m_parent->isValidPosition(getPosRelative() + p);
}
}
MapNode MapBlock::getNodeParent(v3s16 p)
{
if(isValidPosition(p) == false)
{
return m_parent->getNode(getPosRelative() + p);
}
else
{
if(data == NULL)
throw InvalidPositionException();
return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
}
}
void MapBlock::setNodeParent(v3s16 p, MapNode & n)
{
if(isValidPosition(p) == false)
{
m_parent->setNode(getPosRelative() + p, n);
}
else
{
if(data == NULL)
throw InvalidPositionException();
data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X] = n;
}
}
MapNode MapBlock::getNodeParentNoEx(v3s16 p)
{
if(isValidPosition(p) == false)
{
try{
return m_parent->getNode(getPosRelative() + p);
}
catch(InvalidPositionException &e)
{
return MapNode(CONTENT_IGNORE);
}
}
else
{
if(data == NULL)
{
return MapNode(CONTENT_IGNORE);
}
return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
}
} }
/* /*
@ -611,11 +560,7 @@ private:
core::array<PreMeshBuffer> m_prebuffers; core::array<PreMeshBuffer> m_prebuffers;
}; };
scene::SMesh* makeMapBlockMesh( scene::SMesh* makeMapBlockMesh(MeshMakeData *data)
u32 daynight_ratio,
NodeModMap &temp_mods,
VoxelManipulator &vmanip,
v3s16 blockpos_nodes)
{ {
// 4-21ms for MAP_BLOCKSIZE=16 // 4-21ms for MAP_BLOCKSIZE=16
// 24-155ms for MAP_BLOCKSIZE=32 // 24-155ms for MAP_BLOCKSIZE=32
@ -623,6 +568,8 @@ scene::SMesh* makeMapBlockMesh(
core::array<FastFace> fastfaces_new; core::array<FastFace> fastfaces_new;
v3s16 blockpos_nodes = data->m_blockpos*MAP_BLOCKSIZE;
// floating point conversion // floating point conversion
v3f posRelative_f(blockpos_nodes.X, blockpos_nodes.Y, blockpos_nodes.Z); v3f posRelative_f(blockpos_nodes.X, blockpos_nodes.Y, blockpos_nodes.Z);
@ -653,15 +600,15 @@ scene::SMesh* makeMapBlockMesh(
*/ */
for(s16 y=0; y<MAP_BLOCKSIZE; y++){ for(s16 y=0; y<MAP_BLOCKSIZE; y++){
for(s16 z=0; z<MAP_BLOCKSIZE; z++){ for(s16 z=0; z<MAP_BLOCKSIZE; z++){
updateFastFaceRow(daynight_ratio, posRelative_f, updateFastFaceRow(data->m_daynight_ratio, posRelative_f,
v3s16(0,y,z), MAP_BLOCKSIZE, v3s16(0,y,z), MAP_BLOCKSIZE,
v3s16(1,0,0), //dir v3s16(1,0,0), //dir
v3f (1,0,0), v3f (1,0,0),
v3s16(0,1,0), //face dir v3s16(0,1,0), //face dir
v3f (0,1,0), v3f (0,1,0),
fastfaces_new, fastfaces_new,
temp_mods, data->m_temp_mods,
vmanip, data->m_vmanip,
blockpos_nodes); blockpos_nodes);
} }
} }
@ -670,15 +617,15 @@ scene::SMesh* makeMapBlockMesh(
*/ */
for(s16 x=0; x<MAP_BLOCKSIZE; x++){ for(s16 x=0; x<MAP_BLOCKSIZE; x++){
for(s16 y=0; y<MAP_BLOCKSIZE; y++){ for(s16 y=0; y<MAP_BLOCKSIZE; y++){
updateFastFaceRow(daynight_ratio, posRelative_f, updateFastFaceRow(data->m_daynight_ratio, posRelative_f,
v3s16(x,y,0), MAP_BLOCKSIZE, v3s16(x,y,0), MAP_BLOCKSIZE,
v3s16(0,0,1), v3s16(0,0,1),
v3f (0,0,1), v3f (0,0,1),
v3s16(1,0,0), v3s16(1,0,0),
v3f (1,0,0), v3f (1,0,0),
fastfaces_new, fastfaces_new,
temp_mods, data->m_temp_mods,
vmanip, data->m_vmanip,
blockpos_nodes); blockpos_nodes);
} }
} }
@ -687,15 +634,15 @@ scene::SMesh* makeMapBlockMesh(
*/ */
for(s16 z=0; z<MAP_BLOCKSIZE; z++){ for(s16 z=0; z<MAP_BLOCKSIZE; z++){
for(s16 y=0; y<MAP_BLOCKSIZE; y++){ for(s16 y=0; y<MAP_BLOCKSIZE; y++){
updateFastFaceRow(daynight_ratio, posRelative_f, updateFastFaceRow(data->m_daynight_ratio, posRelative_f,
v3s16(0,y,z), MAP_BLOCKSIZE, v3s16(0,y,z), MAP_BLOCKSIZE,
v3s16(1,0,0), v3s16(1,0,0),
v3f (1,0,0), v3f (1,0,0),
v3s16(0,0,1), v3s16(0,0,1),
v3f (0,0,1), v3f (0,0,1),
fastfaces_new, fastfaces_new,
temp_mods, data->m_temp_mods,
vmanip, data->m_vmanip,
blockpos_nodes); blockpos_nodes);
} }
} }
@ -781,7 +728,7 @@ scene::SMesh* makeMapBlockMesh(
{ {
v3s16 p(x,y,z); v3s16 p(x,y,z);
MapNode &n = vmanip.getNodeRef(blockpos_nodes+p); MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes+p);
/* /*
Add torches to mesh Add torches to mesh
@ -851,7 +798,7 @@ scene::SMesh* makeMapBlockMesh(
*/ */
if(n.d == CONTENT_SIGN_WALL) if(n.d == CONTENT_SIGN_WALL)
{ {
u8 l = decode_light(n.getLightBlend(daynight_ratio)); u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
video::SColor c(255,l,l,l); video::SColor c(255,l,l,l);
float d = (float)BS/16; float d = (float)BS/16;
@ -907,13 +854,11 @@ scene::SMesh* makeMapBlockMesh(
else if(n.d == CONTENT_WATER) else if(n.d == CONTENT_WATER)
{ {
bool top_is_water = false; bool top_is_water = false;
try{ MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
MapNode n = vmanip.getNode(blockpos_nodes + v3s16(x,y+1,z)); if(n.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE)
if(n.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE) top_is_water = true;
top_is_water = true;
}catch(InvalidPositionException &e){}
u8 l = decode_light(n.getLightBlend(daynight_ratio)); u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
video::SColor c(WATER_ALPHA,l,l,l); video::SColor c(WATER_ALPHA,l,l,l);
// Neighbor water levels (key = relative position) // Neighbor water levels (key = relative position)
@ -938,11 +883,11 @@ scene::SMesh* makeMapBlockMesh(
u8 content = CONTENT_AIR; u8 content = CONTENT_AIR;
float level = -0.5 * BS; float level = -0.5 * BS;
u8 flags = 0; u8 flags = 0;
try{ // Check neighbor
// Check neighbor v3s16 p2 = p + neighbor_dirs[i];
v3s16 p2 = p + neighbor_dirs[i]; MapNode n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
MapNode n2 = vmanip.getNode(blockpos_nodes + p2); if(n2.d != CONTENT_IGNORE)
{
content = n2.d; content = n2.d;
if(n2.d == CONTENT_WATERSOURCE) if(n2.d == CONTENT_WATERSOURCE)
@ -955,11 +900,10 @@ scene::SMesh* makeMapBlockMesh(
// NOTE: This doesn't get executed if neighbor // NOTE: This doesn't get executed if neighbor
// doesn't exist // doesn't exist
p2.Y += 1; p2.Y += 1;
n2 = vmanip.getNode(blockpos_nodes + p2); n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
if(n2.d == CONTENT_WATERSOURCE || n2.d == CONTENT_WATER) if(n2.d == CONTENT_WATERSOURCE || n2.d == CONTENT_WATER)
flags |= neighborflag_top_is_water; flags |= neighborflag_top_is_water;
} }
catch(InvalidPositionException &e){}
neighbor_levels.insert(neighbor_dirs[i], level); neighbor_levels.insert(neighbor_dirs[i], level);
neighbor_contents.insert(neighbor_dirs[i], content); neighbor_contents.insert(neighbor_dirs[i], content);
@ -1169,20 +1113,18 @@ scene::SMesh* makeMapBlockMesh(
{ {
//bool top_is_water = false; //bool top_is_water = false;
bool top_is_air = false; bool top_is_air = false;
try{ MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
MapNode n = vmanip.getNode(blockpos_nodes + v3s16(x,y+1,z)); /*if(n.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE)
/*if(n.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE) top_is_water = true;*/
top_is_water = true;*/ if(n.d == CONTENT_AIR)
if(n.d == CONTENT_AIR) top_is_air = true;
top_is_air = true;
}catch(InvalidPositionException &e){}
/*if(top_is_water == true) /*if(top_is_water == true)
continue;*/ continue;*/
if(top_is_air == false) if(top_is_air == false)
continue; continue;
u8 l = decode_light(n.getLightBlend(daynight_ratio)); u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
video::SColor c(WATER_ALPHA,l,l,l); video::SColor c(WATER_ALPHA,l,l,l);
video::S3DVertex vertices[4] = video::S3DVertex vertices[4] =
@ -1216,8 +1158,8 @@ scene::SMesh* makeMapBlockMesh(
*/ */
else if(n.d == CONTENT_LEAVES && new_style_leaves) else if(n.d == CONTENT_LEAVES && new_style_leaves)
{ {
/*u8 l = decode_light(n.getLightBlend(daynight_ratio));*/ /*u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));*/
u8 l = decode_light(undiminish_light(n.getLightBlend(daynight_ratio))); u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
video::SColor c(255,l,l,l); video::SColor c(255,l,l,l);
for(u32 j=0; j<6; j++) for(u32 j=0; j<6; j++)
@ -1331,13 +1273,113 @@ scene::SMesh* makeMapBlockMesh(
//std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl; //std::cout<<"added "<<fastfaces.getSize()<<" faces."<<std::endl;
} }
/*scene::SMesh* makeMapBlockMesh(
u32 daynight_ratio, /*
NodeModMap &temp_mods, MapBlock
VoxelManipulator &vmanip, */
v3s16 blockpos_nodes)
MapBlock::MapBlock(NodeContainer *parent, v3s16 pos, bool dummy):
m_parent(parent),
m_pos(pos),
changed(true),
is_underground(false),
m_lighting_expired(true),
m_day_night_differs(false),
//m_not_fully_generated(false),
m_objects(this)
{ {
}*/ data = NULL;
if(dummy == false)
reallocate();
m_spawn_timer = -10000;
#ifndef SERVER
m_mesh_expired = false;
mesh_mutex.Init();
mesh = NULL;
m_temp_mods_mutex.Init();
#endif
}
MapBlock::~MapBlock()
{
#ifndef SERVER
{
JMutexAutoLock lock(mesh_mutex);
if(mesh)
{
mesh->drop();
mesh = NULL;
}
}
#endif
if(data)
delete[] data;
}
bool MapBlock::isValidPositionParent(v3s16 p)
{
if(isValidPosition(p))
{
return true;
}
else{
return m_parent->isValidPosition(getPosRelative() + p);
}
}
MapNode MapBlock::getNodeParent(v3s16 p)
{
if(isValidPosition(p) == false)
{
return m_parent->getNode(getPosRelative() + p);
}
else
{
if(data == NULL)
throw InvalidPositionException();
return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
}
}
void MapBlock::setNodeParent(v3s16 p, MapNode & n)
{
if(isValidPosition(p) == false)
{
m_parent->setNode(getPosRelative() + p, n);
}
else
{
if(data == NULL)
throw InvalidPositionException();
data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X] = n;
}
}
MapNode MapBlock::getNodeParentNoEx(v3s16 p)
{
if(isValidPosition(p) == false)
{
try{
return m_parent->getNode(getPosRelative() + p);
}
catch(InvalidPositionException &e)
{
return MapNode(CONTENT_IGNORE);
}
}
else
{
if(data == NULL)
{
return MapNode(CONTENT_IGNORE);
}
return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
}
}
#if 1 #if 1
void MapBlock::updateMesh(u32 daynight_ratio) void MapBlock::updateMesh(u32 daynight_ratio)
@ -1353,52 +1395,10 @@ void MapBlock::updateMesh(u32 daynight_ratio)
} }
#endif #endif
/* MeshMakeData data;
Avoid interlocks by copying m_temp_mods data.fill(daynight_ratio, this);
*/
NodeModMap temp_mods;
copyTempMods(temp_mods);
v3s16 blockpos_nodes = getPosRelative(); scene::SMesh *mesh_new = makeMapBlockMesh(&data);
VoxelManipulator vmanip;
// Allocate this block + borders
vmanip.addArea(VoxelArea(blockpos_nodes-v3s16(1,1,1),
blockpos_nodes+v3s16(1,1,1)*MAP_BLOCKSIZE));
// Copy our data
copyTo(vmanip);
// Copy borders from map
// +-Z
for(s16 x=-1; x<=MAP_BLOCKSIZE; x++)
for(s16 y=-1; y<=MAP_BLOCKSIZE; y++)
for(s16 z=-1; z<=MAP_BLOCKSIZE; z+=MAP_BLOCKSIZE+1)
{
v3s16 p(x,y,z);
vmanip.setNodeNoRef(blockpos_nodes+p, getNodeParentNoEx(p));
}
// +-Y
for(s16 x=-1; x<=MAP_BLOCKSIZE; x++)
for(s16 y=-1; y<=MAP_BLOCKSIZE; y+=MAP_BLOCKSIZE+1)
for(s16 z=-1; z<=MAP_BLOCKSIZE; z++)
{
v3s16 p(x,y,z);
vmanip.setNodeNoRef(blockpos_nodes+p, getNodeParentNoEx(p));
}
// +-Z
for(s16 x=-1; x<=MAP_BLOCKSIZE; x+=MAP_BLOCKSIZE+1)
for(s16 y=-1; y<=MAP_BLOCKSIZE; y++)
for(s16 z=-1; z<=MAP_BLOCKSIZE; z++)
{
v3s16 p(x,y,z);
vmanip.setNodeNoRef(blockpos_nodes+p, getNodeParentNoEx(p));
}
scene::SMesh *mesh_new = makeMapBlockMesh(
daynight_ratio,
temp_mods,
vmanip,
getPosRelative()
);
/* /*
Replace the mesh Replace the mesh

View File

@ -156,20 +156,42 @@ public:
virtual MapNode getNode(v3s16 p) = 0; virtual MapNode getNode(v3s16 p) = 0;
virtual void setNode(v3s16 p, MapNode & n) = 0; virtual void setNode(v3s16 p, MapNode & n) = 0;
virtual u16 nodeContainerId() const = 0; virtual u16 nodeContainerId() const = 0;
MapNode getNodeNoEx(v3s16 p)
{
try{
return getNode(p);
}
catch(InvalidPositionException &e){
return MapNode(CONTENT_IGNORE);
}
}
}; };
/* /*
Plain functions in mapblock.cpp Mesh making stuff
*/ */
class MapBlock;
struct MeshMakeData
{
u32 m_daynight_ratio;
NodeModMap m_temp_mods;
VoxelManipulator m_vmanip;
v3s16 m_blockpos;
/*
Copy central data directly from block, and other data from
parent of block.
*/
void fill(u32 daynight_ratio, MapBlock *block);
};
u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2, u8 getFaceLight(u32 daynight_ratio, MapNode n, MapNode n2,
v3s16 face_dir); v3s16 face_dir);
scene::SMesh* makeMapBlockMesh( scene::SMesh* makeMapBlockMesh(MeshMakeData *data);
u32 daynight_ratio,
NodeModMap &temp_mods,
VoxelManipulator &vmanip,
v3s16 blockpos_nodes);
/* /*
MapBlock itself MapBlock itself
@ -661,8 +683,7 @@ private:
Private member variables Private member variables
*/ */
// Parent container (practically the Map) // NOTE: Lots of things rely on this being the Map
// Not a MapSector, it is just a structural element.
NodeContainer *m_parent; NodeContainer *m_parent;
// Position in blocks on parent // Position in blocks on parent
v3s16 m_pos; v3s16 m_pos;

View File

@ -1467,6 +1467,10 @@ protected:
core::list<T> m_list; core::list<T> m_list;
}; };
/*
A single worker thread - multiple client threads queue framework.
*/
template<typename Caller, typename Data> template<typename Caller, typename Data>
class CallerInfo class CallerInfo
{ {
@ -1516,11 +1520,6 @@ public:
core::list<CallerInfo<Caller, CallerData> > callers; core::list<CallerInfo<Caller, CallerData> > callers;
}; };
/*
Quickhands for typical request-result queues.
Used for distributing work between threads.
*/
template<typename Key, typename T, typename Caller, typename CallerData> template<typename Key, typename T, typename Caller, typename CallerData>
class RequestQueue class RequestQueue
{ {