mirror of
https://github.com/minetest/minetest.git
synced 2024-08-18 20:44:16 +02:00
MeshUpdateQueue: Add a MapBlock cache that minimizes the amount of MapBlock copying done in the main thread
Cache size is configurable by the meshgen_block_cache_size (default 20 MB). New profiler stats: - MeshUpdateQueue MapBlock cache hit % - MeshUpdateQueue MapBlock cache size kB Removes one type of stutter that was seen on the client when received MapBlocks were being handled. (the "MeshMakeData::fill" stutter) Kind of related to at least #5239 Originally preceded by these commits, now includes them: - Move the mesh generator thread into src/mesh_generator_thread.{cpp,h} - mesh_generator_thread.cpp: Update code style - MeshUpdateThread: Modify interface to house a different implementation: Actual functionality will be changed by next commits. - MeshMakeData: Add fillBlockData() interface (so that caller can fill in stuff from eg. a MapBlock cache)
This commit is contained in:
parent
4323ad163f
commit
04cc9de8f2
@ -185,6 +185,7 @@ LOCAL_SRC_FILES := \
|
|||||||
jni/src/mapnode.cpp \
|
jni/src/mapnode.cpp \
|
||||||
jni/src/mapsector.cpp \
|
jni/src/mapsector.cpp \
|
||||||
jni/src/mesh.cpp \
|
jni/src/mesh.cpp \
|
||||||
|
jni/src/mesh_generator_thread.cpp \
|
||||||
jni/src/metadata.cpp \
|
jni/src/metadata.cpp \
|
||||||
jni/src/mg_biome.cpp \
|
jni/src/mg_biome.cpp \
|
||||||
jni/src/mg_decoration.cpp \
|
jni/src/mg_decoration.cpp \
|
||||||
|
@ -551,6 +551,11 @@ enable_mesh_cache (Mesh cache) bool false
|
|||||||
# down the rate of mesh updates, thus reducing jitter on slower clients.
|
# down the rate of mesh updates, thus reducing jitter on slower clients.
|
||||||
mesh_generation_interval (Mapblock mesh generation delay) int 0 0 50
|
mesh_generation_interval (Mapblock mesh generation delay) int 0 0 50
|
||||||
|
|
||||||
|
# Size of the MapBlock cache of the mesh generator. Increasing this will
|
||||||
|
# increase the cache hit %, reducing the data being copied from the main
|
||||||
|
# thread, thus reducing jitter.
|
||||||
|
meshgen_block_cache_size (Mapblock mesh generator's MapBlock cache size MB) int 20 0 1000
|
||||||
|
|
||||||
# Enables minimap.
|
# Enables minimap.
|
||||||
enable_minimap (Minimap) bool true
|
enable_minimap (Minimap) bool true
|
||||||
|
|
||||||
|
@ -644,6 +644,12 @@
|
|||||||
# type: int min: 0 max: 50
|
# type: int min: 0 max: 50
|
||||||
# mesh_generation_interval = 0
|
# mesh_generation_interval = 0
|
||||||
|
|
||||||
|
# Size of the MapBlock cache of the mesh generator. Increasing this will
|
||||||
|
# increase the cache hit %, reducing the data being copied from the main
|
||||||
|
# thread, thus reducing jitter.
|
||||||
|
# type: int min: 0 max: 1000
|
||||||
|
# meshgen_block_cache_size = 20
|
||||||
|
|
||||||
# Enables minimap.
|
# Enables minimap.
|
||||||
# type: bool
|
# type: bool
|
||||||
# enable_minimap = true
|
# enable_minimap = true
|
||||||
|
@ -522,6 +522,7 @@ set(client_SRCS
|
|||||||
main.cpp
|
main.cpp
|
||||||
mapblock_mesh.cpp
|
mapblock_mesh.cpp
|
||||||
mesh.cpp
|
mesh.cpp
|
||||||
|
mesh_generator_thread.cpp
|
||||||
minimap.cpp
|
minimap.cpp
|
||||||
particles.cpp
|
particles.cpp
|
||||||
shader.cpp
|
shader.cpp
|
||||||
|
178
src/client.cpp
178
src/client.cpp
@ -50,147 +50,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
|
|||||||
|
|
||||||
extern gui::IGUIEnvironment* guienv;
|
extern gui::IGUIEnvironment* guienv;
|
||||||
|
|
||||||
/*
|
|
||||||
QueuedMeshUpdate
|
|
||||||
*/
|
|
||||||
|
|
||||||
QueuedMeshUpdate::QueuedMeshUpdate():
|
|
||||||
p(-1337,-1337,-1337),
|
|
||||||
data(NULL),
|
|
||||||
ack_block_to_server(false)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
QueuedMeshUpdate::~QueuedMeshUpdate()
|
|
||||||
{
|
|
||||||
if(data)
|
|
||||||
delete data;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
MeshUpdateQueue
|
|
||||||
*/
|
|
||||||
|
|
||||||
MeshUpdateQueue::MeshUpdateQueue()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
MeshUpdateQueue::~MeshUpdateQueue()
|
|
||||||
{
|
|
||||||
MutexAutoLock lock(m_mutex);
|
|
||||||
|
|
||||||
for(std::vector<QueuedMeshUpdate*>::iterator
|
|
||||||
i = m_queue.begin();
|
|
||||||
i != m_queue.end(); ++i)
|
|
||||||
{
|
|
||||||
QueuedMeshUpdate *q = *i;
|
|
||||||
delete q;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
peer_id=0 adds with nobody to send to
|
|
||||||
*/
|
|
||||||
void MeshUpdateQueue::addBlock(v3s16 p, MeshMakeData *data, bool ack_block_to_server, bool urgent)
|
|
||||||
{
|
|
||||||
DSTACK(FUNCTION_NAME);
|
|
||||||
|
|
||||||
assert(data); // pre-condition
|
|
||||||
|
|
||||||
MutexAutoLock lock(m_mutex);
|
|
||||||
|
|
||||||
if(urgent)
|
|
||||||
m_urgents.insert(p);
|
|
||||||
|
|
||||||
/*
|
|
||||||
Find if block is already in queue.
|
|
||||||
If it is, update the data and quit.
|
|
||||||
*/
|
|
||||||
for(std::vector<QueuedMeshUpdate*>::iterator
|
|
||||||
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 *MeshUpdateQueue::pop()
|
|
||||||
{
|
|
||||||
MutexAutoLock lock(m_mutex);
|
|
||||||
|
|
||||||
bool must_be_urgent = !m_urgents.empty();
|
|
||||||
for(std::vector<QueuedMeshUpdate*>::iterator
|
|
||||||
i = m_queue.begin();
|
|
||||||
i != m_queue.end(); ++i)
|
|
||||||
{
|
|
||||||
QueuedMeshUpdate *q = *i;
|
|
||||||
if(must_be_urgent && m_urgents.count(q->p) == 0)
|
|
||||||
continue;
|
|
||||||
m_queue.erase(i);
|
|
||||||
m_urgents.erase(q->p);
|
|
||||||
return q;
|
|
||||||
}
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
MeshUpdateThread
|
|
||||||
*/
|
|
||||||
|
|
||||||
MeshUpdateThread::MeshUpdateThread() : UpdateThread("Mesh")
|
|
||||||
{
|
|
||||||
m_generation_interval = g_settings->getU16("mesh_generation_interval");
|
|
||||||
m_generation_interval = rangelim(m_generation_interval, 0, 50);
|
|
||||||
}
|
|
||||||
|
|
||||||
void MeshUpdateThread::enqueueUpdate(v3s16 p, MeshMakeData *data,
|
|
||||||
bool ack_block_to_server, bool urgent)
|
|
||||||
{
|
|
||||||
m_queue_in.addBlock(p, data, ack_block_to_server, urgent);
|
|
||||||
deferUpdate();
|
|
||||||
}
|
|
||||||
|
|
||||||
void MeshUpdateThread::doUpdate()
|
|
||||||
{
|
|
||||||
QueuedMeshUpdate *q;
|
|
||||||
while ((q = m_queue_in.pop())) {
|
|
||||||
if (m_generation_interval)
|
|
||||||
sleep_ms(m_generation_interval);
|
|
||||||
ScopeProfiler sp(g_profiler, "Client: Mesh making");
|
|
||||||
|
|
||||||
MapBlockMesh *mesh_new = new MapBlockMesh(q->data, m_camera_offset);
|
|
||||||
|
|
||||||
MeshUpdateResult r;
|
|
||||||
r.p = q->p;
|
|
||||||
r.mesh = mesh_new;
|
|
||||||
r.ack_block_to_server = q->ack_block_to_server;
|
|
||||||
|
|
||||||
m_queue_out.push_back(r);
|
|
||||||
|
|
||||||
delete q;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Client
|
Client
|
||||||
*/
|
*/
|
||||||
@ -220,7 +79,7 @@ Client::Client(
|
|||||||
m_nodedef(nodedef),
|
m_nodedef(nodedef),
|
||||||
m_sound(sound),
|
m_sound(sound),
|
||||||
m_event(event),
|
m_event(event),
|
||||||
m_mesh_update_thread(),
|
m_mesh_update_thread(this),
|
||||||
m_env(
|
m_env(
|
||||||
new ClientMap(this, control,
|
new ClientMap(this, control,
|
||||||
device->getSceneManager()->getRootSceneNode(),
|
device->getSceneManager()->getRootSceneNode(),
|
||||||
@ -269,12 +128,6 @@ Client::Client(
|
|||||||
m_minimap = new Minimap(device, this);
|
m_minimap = new Minimap(device, this);
|
||||||
m_cache_save_interval = g_settings->getU16("server_map_save_interval");
|
m_cache_save_interval = g_settings->getU16("server_map_save_interval");
|
||||||
|
|
||||||
m_cache_smooth_lighting = g_settings->getBool("smooth_lighting");
|
|
||||||
m_cache_enable_shaders = g_settings->getBool("enable_shaders");
|
|
||||||
m_cache_use_tangent_vertices = m_cache_enable_shaders && (
|
|
||||||
g_settings->getBool("enable_bumpmapping") ||
|
|
||||||
g_settings->getBool("enable_parallax_occlusion"));
|
|
||||||
|
|
||||||
m_modding_enabled = g_settings->getBool("enable_client_modding");
|
m_modding_enabled = g_settings->getBool("enable_client_modding");
|
||||||
m_script = new ClientScripting(this);
|
m_script = new ClientScripting(this);
|
||||||
m_env.setScript(m_script);
|
m_env.setScript(m_script);
|
||||||
@ -1605,6 +1458,11 @@ int Client::getCrackLevel()
|
|||||||
return m_crack_level;
|
return m_crack_level;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
v3s16 Client::getCrackPos()
|
||||||
|
{
|
||||||
|
return m_crack_pos;
|
||||||
|
}
|
||||||
|
|
||||||
void Client::setCrack(int level, v3s16 pos)
|
void Client::setCrack(int level, v3s16 pos)
|
||||||
{
|
{
|
||||||
int old_crack_level = m_crack_level;
|
int old_crack_level = m_crack_level;
|
||||||
@ -1670,28 +1528,14 @@ void Client::typeChatMessage(const std::wstring &message)
|
|||||||
|
|
||||||
void Client::addUpdateMeshTask(v3s16 p, bool ack_to_server, bool urgent)
|
void Client::addUpdateMeshTask(v3s16 p, bool ack_to_server, bool urgent)
|
||||||
{
|
{
|
||||||
|
// Check if the block exists to begin with. In the case when a non-existing
|
||||||
|
// neighbor is automatically added, it may not. In that case we don't want
|
||||||
|
// to tell the mesh update thread about it.
|
||||||
MapBlock *b = m_env.getMap().getBlockNoCreateNoEx(p);
|
MapBlock *b = m_env.getMap().getBlockNoCreateNoEx(p);
|
||||||
if(b == NULL)
|
if (b == NULL)
|
||||||
return;
|
return;
|
||||||
|
|
||||||
/*
|
m_mesh_update_thread.updateBlock(&m_env.getMap(), p, ack_to_server, urgent);
|
||||||
Create a task to update the mesh of the block
|
|
||||||
*/
|
|
||||||
|
|
||||||
MeshMakeData *data = new MeshMakeData(this, m_cache_enable_shaders,
|
|
||||||
m_cache_use_tangent_vertices);
|
|
||||||
|
|
||||||
{
|
|
||||||
//TimeTaker timer("data fill");
|
|
||||||
// Release: ~0ms
|
|
||||||
// Debug: 1-6ms, avg=2ms
|
|
||||||
data->fill(b);
|
|
||||||
data->setCrack(m_crack_level, m_crack_pos);
|
|
||||||
data->setSmoothLighting(m_cache_smooth_lighting);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add task to queue
|
|
||||||
m_mesh_update_thread.enqueueUpdate(p, data, ack_to_server, urgent);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server, bool urgent)
|
void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server, bool urgent)
|
||||||
|
83
src/client.h
83
src/client.h
@ -36,6 +36,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
|
|||||||
#include "particles.h"
|
#include "particles.h"
|
||||||
#include "mapnode.h"
|
#include "mapnode.h"
|
||||||
#include "tileanimation.h"
|
#include "tileanimation.h"
|
||||||
|
#include "mesh_generator_thread.h"
|
||||||
|
|
||||||
struct MeshMakeData;
|
struct MeshMakeData;
|
||||||
class MapBlockMesh;
|
class MapBlockMesh;
|
||||||
@ -54,88 +55,12 @@ struct MinimapMapblock;
|
|||||||
class Camera;
|
class Camera;
|
||||||
class NetworkPacket;
|
class NetworkPacket;
|
||||||
|
|
||||||
struct QueuedMeshUpdate
|
|
||||||
{
|
|
||||||
v3s16 p;
|
|
||||||
MeshMakeData *data;
|
|
||||||
bool ack_block_to_server;
|
|
||||||
|
|
||||||
QueuedMeshUpdate();
|
|
||||||
~QueuedMeshUpdate();
|
|
||||||
};
|
|
||||||
|
|
||||||
enum LocalClientState {
|
enum LocalClientState {
|
||||||
LC_Created,
|
LC_Created,
|
||||||
LC_Init,
|
LC_Init,
|
||||||
LC_Ready
|
LC_Ready
|
||||||
};
|
};
|
||||||
|
|
||||||
/*
|
|
||||||
A thread-safe queue of mesh update tasks
|
|
||||||
*/
|
|
||||||
class MeshUpdateQueue
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
MeshUpdateQueue();
|
|
||||||
|
|
||||||
~MeshUpdateQueue();
|
|
||||||
|
|
||||||
/*
|
|
||||||
peer_id=0 adds with nobody to send to
|
|
||||||
*/
|
|
||||||
void addBlock(v3s16 p, MeshMakeData *data,
|
|
||||||
bool ack_block_to_server, bool urgent);
|
|
||||||
|
|
||||||
// Returned pointer must be deleted
|
|
||||||
// Returns NULL if queue is empty
|
|
||||||
QueuedMeshUpdate * pop();
|
|
||||||
|
|
||||||
u32 size()
|
|
||||||
{
|
|
||||||
MutexAutoLock lock(m_mutex);
|
|
||||||
return m_queue.size();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
std::vector<QueuedMeshUpdate*> m_queue;
|
|
||||||
std::set<v3s16> m_urgents;
|
|
||||||
Mutex m_mutex;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct MeshUpdateResult
|
|
||||||
{
|
|
||||||
v3s16 p;
|
|
||||||
MapBlockMesh *mesh;
|
|
||||||
bool ack_block_to_server;
|
|
||||||
|
|
||||||
MeshUpdateResult():
|
|
||||||
p(-1338,-1338,-1338),
|
|
||||||
mesh(NULL),
|
|
||||||
ack_block_to_server(false)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
class MeshUpdateThread : public UpdateThread
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
MeshUpdateQueue m_queue_in;
|
|
||||||
int m_generation_interval;
|
|
||||||
|
|
||||||
protected:
|
|
||||||
virtual void doUpdate();
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
MeshUpdateThread();
|
|
||||||
|
|
||||||
void enqueueUpdate(v3s16 p, MeshMakeData *data,
|
|
||||||
bool ack_block_to_server, bool urgent);
|
|
||||||
MutexedQueue<MeshUpdateResult> m_queue_out;
|
|
||||||
|
|
||||||
v3s16 m_camera_offset;
|
|
||||||
};
|
|
||||||
|
|
||||||
enum ClientEventType
|
enum ClientEventType
|
||||||
{
|
{
|
||||||
CE_NONE,
|
CE_NONE,
|
||||||
@ -471,6 +396,7 @@ public:
|
|||||||
float getAnimationTime();
|
float getAnimationTime();
|
||||||
|
|
||||||
int getCrackLevel();
|
int getCrackLevel();
|
||||||
|
v3s16 getCrackPos();
|
||||||
void setCrack(int level, v3s16 pos);
|
void setCrack(int level, v3s16 pos);
|
||||||
|
|
||||||
u16 getHP();
|
u16 getHP();
|
||||||
@ -726,11 +652,6 @@ private:
|
|||||||
IntervalLimiter m_localdb_save_interval;
|
IntervalLimiter m_localdb_save_interval;
|
||||||
u16 m_cache_save_interval;
|
u16 m_cache_save_interval;
|
||||||
|
|
||||||
// TODO: Add callback to update these when g_settings changes
|
|
||||||
bool m_cache_smooth_lighting;
|
|
||||||
bool m_cache_enable_shaders;
|
|
||||||
bool m_cache_use_tangent_vertices;
|
|
||||||
|
|
||||||
ClientScripting *m_script;
|
ClientScripting *m_script;
|
||||||
bool m_modding_enabled;
|
bool m_modding_enabled;
|
||||||
UNORDERED_MAP<std::string, ModMetadata *> m_mod_storages;
|
UNORDERED_MAP<std::string, ModMetadata *> m_mod_storages;
|
||||||
|
@ -39,6 +39,7 @@ void set_default_settings(Settings *settings)
|
|||||||
settings->setDefault("sound_volume", "0.8");
|
settings->setDefault("sound_volume", "0.8");
|
||||||
settings->setDefault("enable_mesh_cache", "false");
|
settings->setDefault("enable_mesh_cache", "false");
|
||||||
settings->setDefault("mesh_generation_interval", "0");
|
settings->setDefault("mesh_generation_interval", "0");
|
||||||
|
settings->setDefault("meshgen_block_cache_size", "20");
|
||||||
settings->setDefault("enable_vbo", "true");
|
settings->setDefault("enable_vbo", "true");
|
||||||
settings->setDefault("free_move", "false");
|
settings->setDefault("free_move", "false");
|
||||||
settings->setDefault("fast_move", "false");
|
settings->setDefault("fast_move", "false");
|
||||||
|
@ -154,6 +154,11 @@ public:
|
|||||||
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE);
|
raiseModified(MOD_STATE_WRITE_NEEDED, MOD_REASON_REALLOCATE);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
MapNode* getData()
|
||||||
|
{
|
||||||
|
return data;
|
||||||
|
}
|
||||||
|
|
||||||
////
|
////
|
||||||
//// Modification tracking methods
|
//// Modification tracking methods
|
||||||
////
|
////
|
||||||
|
@ -48,49 +48,43 @@ MeshMakeData::MeshMakeData(Client *client, bool use_shaders,
|
|||||||
m_use_tangent_vertices(use_tangent_vertices)
|
m_use_tangent_vertices(use_tangent_vertices)
|
||||||
{}
|
{}
|
||||||
|
|
||||||
void MeshMakeData::fill(MapBlock *block)
|
void MeshMakeData::fillBlockDataBegin(const v3s16 &blockpos)
|
||||||
{
|
{
|
||||||
m_blockpos = block->getPos();
|
m_blockpos = blockpos;
|
||||||
|
|
||||||
v3s16 blockpos_nodes = m_blockpos*MAP_BLOCKSIZE;
|
v3s16 blockpos_nodes = m_blockpos*MAP_BLOCKSIZE;
|
||||||
|
|
||||||
/*
|
|
||||||
Copy data
|
|
||||||
*/
|
|
||||||
|
|
||||||
// Allocate this block + neighbors
|
|
||||||
m_vmanip.clear();
|
m_vmanip.clear();
|
||||||
VoxelArea voxel_area(blockpos_nodes - v3s16(1,1,1) * MAP_BLOCKSIZE,
|
VoxelArea voxel_area(blockpos_nodes - v3s16(1,1,1) * MAP_BLOCKSIZE,
|
||||||
blockpos_nodes + v3s16(1,1,1) * MAP_BLOCKSIZE*2-v3s16(1,1,1));
|
blockpos_nodes + v3s16(1,1,1) * MAP_BLOCKSIZE*2-v3s16(1,1,1));
|
||||||
m_vmanip.addArea(voxel_area);
|
m_vmanip.addArea(voxel_area);
|
||||||
|
}
|
||||||
|
|
||||||
{
|
void MeshMakeData::fillBlockData(const v3s16 &block_offset, MapNode *data)
|
||||||
//TimeTaker timer("copy central block data");
|
{
|
||||||
// 0ms
|
v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
|
||||||
|
VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
|
||||||
|
|
||||||
// Copy our data
|
v3s16 bp = m_blockpos + block_offset;
|
||||||
block->copyTo(m_vmanip);
|
v3s16 blockpos_nodes = bp * MAP_BLOCKSIZE;
|
||||||
}
|
m_vmanip.copyFrom(data, data_area, v3s16(0,0,0), blockpos_nodes, data_size);
|
||||||
{
|
}
|
||||||
//TimeTaker timer("copy neighbor block data");
|
|
||||||
// 0ms
|
|
||||||
|
|
||||||
/*
|
void MeshMakeData::fill(MapBlock *block)
|
||||||
Copy neighbors. This is lightning fast.
|
{
|
||||||
Copying only the borders would be *very* slow.
|
fillBlockDataBegin(block->getPos());
|
||||||
*/
|
|
||||||
|
|
||||||
// Get map
|
fillBlockData(v3s16(0,0,0), block->getData());
|
||||||
Map *map = block->getParent();
|
|
||||||
|
|
||||||
for(u16 i=0; i<26; i++)
|
// Get map for reading neigbhor blocks
|
||||||
{
|
Map *map = block->getParent();
|
||||||
const v3s16 &dir = g_26dirs[i];
|
|
||||||
v3s16 bp = m_blockpos + dir;
|
for (u16 i=0; i<26; i++) {
|
||||||
MapBlock *b = map->getBlockNoCreateNoEx(bp);
|
const v3s16 &dir = g_26dirs[i];
|
||||||
if(b)
|
v3s16 bp = m_blockpos + dir;
|
||||||
b->copyTo(m_vmanip);
|
MapBlock *b = map->getBlockNoCreateNoEx(bp);
|
||||||
}
|
if(b)
|
||||||
|
fillBlockData(dir, b->getData());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -52,6 +52,12 @@ struct MeshMakeData
|
|||||||
MeshMakeData(Client *client, bool use_shaders,
|
MeshMakeData(Client *client, bool use_shaders,
|
||||||
bool use_tangent_vertices = false);
|
bool use_tangent_vertices = false);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Copy block data manually (to allow optimizations by the caller)
|
||||||
|
*/
|
||||||
|
void fillBlockDataBegin(const v3s16 &blockpos);
|
||||||
|
void fillBlockData(const v3s16 &block_offset, MapNode *data);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Copy central data directly from block, and other data from
|
Copy central data directly from block, and other data from
|
||||||
parent of block.
|
parent of block.
|
||||||
|
329
src/mesh_generator_thread.cpp
Normal file
329
src/mesh_generator_thread.cpp
Normal file
@ -0,0 +1,329 @@
|
|||||||
|
/*
|
||||||
|
Minetest
|
||||||
|
Copyright (C) 2013, 2017 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 "mesh_generator_thread.h"
|
||||||
|
#include "settings.h"
|
||||||
|
#include "profiler.h"
|
||||||
|
#include "client.h"
|
||||||
|
#include "mapblock.h"
|
||||||
|
#include "map.h"
|
||||||
|
|
||||||
|
/*
|
||||||
|
CachedMapBlockData
|
||||||
|
*/
|
||||||
|
|
||||||
|
CachedMapBlockData::CachedMapBlockData():
|
||||||
|
p(-1337,-1337,-1337),
|
||||||
|
data(NULL),
|
||||||
|
refcount_from_queue(0),
|
||||||
|
last_used_timestamp(time(0))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
CachedMapBlockData::~CachedMapBlockData()
|
||||||
|
{
|
||||||
|
assert(refcount_from_queue == 0);
|
||||||
|
|
||||||
|
if (data)
|
||||||
|
delete[] data;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
QueuedMeshUpdate
|
||||||
|
*/
|
||||||
|
|
||||||
|
QueuedMeshUpdate::QueuedMeshUpdate():
|
||||||
|
p(-1337,-1337,-1337),
|
||||||
|
ack_block_to_server(false),
|
||||||
|
urgent(false),
|
||||||
|
crack_level(-1),
|
||||||
|
crack_pos(0,0,0),
|
||||||
|
data(NULL)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
QueuedMeshUpdate::~QueuedMeshUpdate()
|
||||||
|
{
|
||||||
|
if (data)
|
||||||
|
delete data;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
MeshUpdateQueue
|
||||||
|
*/
|
||||||
|
|
||||||
|
MeshUpdateQueue::MeshUpdateQueue(Client *client):
|
||||||
|
m_client(client)
|
||||||
|
{
|
||||||
|
m_cache_enable_shaders = g_settings->getBool("enable_shaders");
|
||||||
|
m_cache_use_tangent_vertices = m_cache_enable_shaders && (
|
||||||
|
g_settings->getBool("enable_bumpmapping") ||
|
||||||
|
g_settings->getBool("enable_parallax_occlusion"));
|
||||||
|
m_cache_smooth_lighting = g_settings->getBool("smooth_lighting");
|
||||||
|
m_meshgen_block_cache_size = g_settings->getS32("meshgen_block_cache_size");
|
||||||
|
}
|
||||||
|
|
||||||
|
MeshUpdateQueue::~MeshUpdateQueue()
|
||||||
|
{
|
||||||
|
MutexAutoLock lock(m_mutex);
|
||||||
|
|
||||||
|
for (std::vector<QueuedMeshUpdate*>::iterator i = m_queue.begin();
|
||||||
|
i != m_queue.end(); ++i) {
|
||||||
|
QueuedMeshUpdate *q = *i;
|
||||||
|
delete q;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void MeshUpdateQueue::addBlock(Map *map, v3s16 p, bool ack_block_to_server, bool urgent)
|
||||||
|
{
|
||||||
|
DSTACK(FUNCTION_NAME);
|
||||||
|
|
||||||
|
MutexAutoLock lock(m_mutex);
|
||||||
|
|
||||||
|
cleanupCache();
|
||||||
|
|
||||||
|
/*
|
||||||
|
Cache the block data (force-update the center block, don't update the
|
||||||
|
neighbors but get them if they aren't already cached)
|
||||||
|
*/
|
||||||
|
std::vector<CachedMapBlockData*> cached_blocks;
|
||||||
|
size_t cache_hit_counter = 0;
|
||||||
|
cached_blocks.reserve(3*3*3);
|
||||||
|
v3s16 dp;
|
||||||
|
for (dp.X = -1; dp.X <= 1; dp.X++)
|
||||||
|
for (dp.Y = -1; dp.Y <= 1; dp.Y++)
|
||||||
|
for (dp.Z = -1; dp.Z <= 1; dp.Z++) {
|
||||||
|
v3s16 p1 = p + dp;
|
||||||
|
CachedMapBlockData *cached_block;
|
||||||
|
if (dp == v3s16(0, 0, 0))
|
||||||
|
cached_block = cacheBlock(map, p1, FORCE_UPDATE);
|
||||||
|
else
|
||||||
|
cached_block = cacheBlock(map, p1, SKIP_UPDATE_IF_ALREADY_CACHED,
|
||||||
|
&cache_hit_counter);
|
||||||
|
cached_blocks.push_back(cached_block);
|
||||||
|
}
|
||||||
|
g_profiler->avg("MeshUpdateQueue MapBlock cache hit %",
|
||||||
|
100.0f * cache_hit_counter / cached_blocks.size());
|
||||||
|
|
||||||
|
/*
|
||||||
|
Mark the block as urgent if requested
|
||||||
|
*/
|
||||||
|
if (urgent)
|
||||||
|
m_urgents.insert(p);
|
||||||
|
|
||||||
|
/*
|
||||||
|
Find if block is already in queue.
|
||||||
|
If it is, update the data and quit.
|
||||||
|
*/
|
||||||
|
for (std::vector<QueuedMeshUpdate*>::iterator i = m_queue.begin();
|
||||||
|
i != m_queue.end(); ++i) {
|
||||||
|
QueuedMeshUpdate *q = *i;
|
||||||
|
if (q->p == p) {
|
||||||
|
// NOTE: We are not adding a new position to the queue, thus
|
||||||
|
// refcount_from_queue stays the same.
|
||||||
|
if(ack_block_to_server)
|
||||||
|
q->ack_block_to_server = true;
|
||||||
|
q->crack_level = m_client->getCrackLevel();
|
||||||
|
q->crack_pos = m_client->getCrackPos();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
Add the block
|
||||||
|
*/
|
||||||
|
QueuedMeshUpdate *q = new QueuedMeshUpdate;
|
||||||
|
q->p = p;
|
||||||
|
q->ack_block_to_server = ack_block_to_server;
|
||||||
|
q->crack_level = m_client->getCrackLevel();
|
||||||
|
q->crack_pos = m_client->getCrackPos();
|
||||||
|
m_queue.push_back(q);
|
||||||
|
|
||||||
|
// This queue entry is a new reference to the cached blocks
|
||||||
|
for (size_t i=0; i<cached_blocks.size(); i++) {
|
||||||
|
cached_blocks[i]->refcount_from_queue++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returned pointer must be deleted
|
||||||
|
// Returns NULL if queue is empty
|
||||||
|
QueuedMeshUpdate *MeshUpdateQueue::pop()
|
||||||
|
{
|
||||||
|
MutexAutoLock lock(m_mutex);
|
||||||
|
|
||||||
|
bool must_be_urgent = !m_urgents.empty();
|
||||||
|
for (std::vector<QueuedMeshUpdate*>::iterator i = m_queue.begin();
|
||||||
|
i != m_queue.end(); ++i) {
|
||||||
|
QueuedMeshUpdate *q = *i;
|
||||||
|
if(must_be_urgent && m_urgents.count(q->p) == 0)
|
||||||
|
continue;
|
||||||
|
m_queue.erase(i);
|
||||||
|
m_urgents.erase(q->p);
|
||||||
|
fillDataFromMapBlockCache(q);
|
||||||
|
return q;
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
CachedMapBlockData* MeshUpdateQueue::cacheBlock(Map *map, v3s16 p, UpdateMode mode,
|
||||||
|
size_t *cache_hit_counter)
|
||||||
|
{
|
||||||
|
std::map<v3s16, CachedMapBlockData*>::iterator it =
|
||||||
|
m_cache.find(p);
|
||||||
|
if (it != m_cache.end()) {
|
||||||
|
// Already in cache
|
||||||
|
CachedMapBlockData *cached_block = it->second;
|
||||||
|
if (mode == SKIP_UPDATE_IF_ALREADY_CACHED) {
|
||||||
|
if (cache_hit_counter)
|
||||||
|
(*cache_hit_counter)++;
|
||||||
|
return cached_block;
|
||||||
|
}
|
||||||
|
MapBlock *b = map->getBlockNoCreateNoEx(p);
|
||||||
|
if (b) {
|
||||||
|
if (cached_block->data == NULL)
|
||||||
|
cached_block->data =
|
||||||
|
new MapNode[MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE];
|
||||||
|
memcpy(cached_block->data, b->getData(),
|
||||||
|
MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE * sizeof(MapNode));
|
||||||
|
} else {
|
||||||
|
delete[] cached_block->data;
|
||||||
|
cached_block->data = NULL;
|
||||||
|
}
|
||||||
|
return cached_block;
|
||||||
|
} else {
|
||||||
|
// Not yet in cache
|
||||||
|
CachedMapBlockData *cached_block = new CachedMapBlockData();
|
||||||
|
m_cache[p] = cached_block;
|
||||||
|
MapBlock *b = map->getBlockNoCreateNoEx(p);
|
||||||
|
if (b) {
|
||||||
|
cached_block->data =
|
||||||
|
new MapNode[MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE];
|
||||||
|
memcpy(cached_block->data, b->getData(),
|
||||||
|
MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE * sizeof(MapNode));
|
||||||
|
}
|
||||||
|
return cached_block;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
CachedMapBlockData* MeshUpdateQueue::getCachedBlock(const v3s16 &p)
|
||||||
|
{
|
||||||
|
std::map<v3s16, CachedMapBlockData*>::iterator it = m_cache.find(p);
|
||||||
|
if (it != m_cache.end()) {
|
||||||
|
return it->second;
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
void MeshUpdateQueue::fillDataFromMapBlockCache(QueuedMeshUpdate *q)
|
||||||
|
{
|
||||||
|
MeshMakeData *data = new MeshMakeData(m_client, m_cache_enable_shaders,
|
||||||
|
m_cache_use_tangent_vertices);
|
||||||
|
q->data = data;
|
||||||
|
|
||||||
|
data->fillBlockDataBegin(q->p);
|
||||||
|
|
||||||
|
int t_now = time(0);
|
||||||
|
|
||||||
|
// Collect data for 3*3*3 blocks from cache
|
||||||
|
v3s16 dp;
|
||||||
|
for (dp.X = -1; dp.X <= 1; dp.X++)
|
||||||
|
for (dp.Y = -1; dp.Y <= 1; dp.Y++)
|
||||||
|
for (dp.Z = -1; dp.Z <= 1; dp.Z++) {
|
||||||
|
v3s16 p = q->p + dp;
|
||||||
|
CachedMapBlockData *cached_block = getCachedBlock(p);
|
||||||
|
if (cached_block) {
|
||||||
|
cached_block->refcount_from_queue--;
|
||||||
|
cached_block->last_used_timestamp = t_now;
|
||||||
|
if (cached_block->data)
|
||||||
|
data->fillBlockData(dp, cached_block->data);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
data->setCrack(q->crack_level, q->crack_pos);
|
||||||
|
data->setSmoothLighting(m_cache_smooth_lighting);
|
||||||
|
}
|
||||||
|
|
||||||
|
void MeshUpdateQueue::cleanupCache()
|
||||||
|
{
|
||||||
|
const int mapblock_kB = MAP_BLOCKSIZE * MAP_BLOCKSIZE * MAP_BLOCKSIZE *
|
||||||
|
sizeof(MapNode) / 1000;
|
||||||
|
g_profiler->avg("MeshUpdateQueue MapBlock cache size kB",
|
||||||
|
mapblock_kB * m_cache.size());
|
||||||
|
|
||||||
|
// The cache size is kept roughly below cache_soft_max_size, not letting
|
||||||
|
// anything get older than cache_seconds_max or deleted before 2 seconds.
|
||||||
|
const int cache_seconds_max = 10;
|
||||||
|
const int cache_soft_max_size = m_meshgen_block_cache_size * 1000 / mapblock_kB;
|
||||||
|
int cache_seconds = MYMAX(2, cache_seconds_max -
|
||||||
|
m_cache.size() / (cache_soft_max_size / cache_seconds_max));
|
||||||
|
|
||||||
|
int t_now = time(0);
|
||||||
|
|
||||||
|
for (std::map<v3s16, CachedMapBlockData*>::iterator it = m_cache.begin();
|
||||||
|
it != m_cache.end(); ) {
|
||||||
|
CachedMapBlockData *cached_block = it->second;
|
||||||
|
if (cached_block->refcount_from_queue == 0 &&
|
||||||
|
cached_block->last_used_timestamp < t_now - cache_seconds) {
|
||||||
|
m_cache.erase(it++);
|
||||||
|
} else {
|
||||||
|
++it;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
MeshUpdateThread
|
||||||
|
*/
|
||||||
|
|
||||||
|
MeshUpdateThread::MeshUpdateThread(Client *client):
|
||||||
|
UpdateThread("Mesh"),
|
||||||
|
m_queue_in(client)
|
||||||
|
{
|
||||||
|
m_generation_interval = g_settings->getU16("mesh_generation_interval");
|
||||||
|
m_generation_interval = rangelim(m_generation_interval, 0, 50);
|
||||||
|
}
|
||||||
|
|
||||||
|
void MeshUpdateThread::updateBlock(Map *map, v3s16 p, bool ack_block_to_server,
|
||||||
|
bool urgent)
|
||||||
|
{
|
||||||
|
// Allow the MeshUpdateQueue to do whatever it wants
|
||||||
|
m_queue_in.addBlock(map, p, ack_block_to_server, urgent);
|
||||||
|
deferUpdate();
|
||||||
|
}
|
||||||
|
|
||||||
|
void MeshUpdateThread::doUpdate()
|
||||||
|
{
|
||||||
|
QueuedMeshUpdate *q;
|
||||||
|
while ((q = m_queue_in.pop())) {
|
||||||
|
if (m_generation_interval)
|
||||||
|
sleep_ms(m_generation_interval);
|
||||||
|
ScopeProfiler sp(g_profiler, "Client: Mesh making");
|
||||||
|
|
||||||
|
MapBlockMesh *mesh_new = new MapBlockMesh(q->data, m_camera_offset);
|
||||||
|
|
||||||
|
MeshUpdateResult r;
|
||||||
|
r.p = q->p;
|
||||||
|
r.mesh = mesh_new;
|
||||||
|
r.ack_block_to_server = q->ack_block_to_server;
|
||||||
|
|
||||||
|
m_queue_out.push_back(r);
|
||||||
|
|
||||||
|
delete q;
|
||||||
|
}
|
||||||
|
}
|
135
src/mesh_generator_thread.h
Normal file
135
src/mesh_generator_thread.h
Normal file
@ -0,0 +1,135 @@
|
|||||||
|
/*
|
||||||
|
Minetest
|
||||||
|
Copyright (C) 2013, 2017 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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef MESH_GENERATOR_THREAD_HEADER
|
||||||
|
#define MESH_GENERATOR_THREAD_HEADER
|
||||||
|
|
||||||
|
#include "mapblock_mesh.h"
|
||||||
|
#include "threading/mutex_auto_lock.h"
|
||||||
|
#include "util/thread.h"
|
||||||
|
|
||||||
|
struct CachedMapBlockData
|
||||||
|
{
|
||||||
|
v3s16 p;
|
||||||
|
MapNode *data; // A copy of the MapBlock's data member
|
||||||
|
int refcount_from_queue;
|
||||||
|
int last_used_timestamp;
|
||||||
|
|
||||||
|
CachedMapBlockData();
|
||||||
|
~CachedMapBlockData();
|
||||||
|
};
|
||||||
|
|
||||||
|
struct QueuedMeshUpdate
|
||||||
|
{
|
||||||
|
v3s16 p;
|
||||||
|
bool ack_block_to_server;
|
||||||
|
bool urgent;
|
||||||
|
int crack_level;
|
||||||
|
v3s16 crack_pos;
|
||||||
|
MeshMakeData *data; // This is generated in MeshUpdateQueue::pop()
|
||||||
|
|
||||||
|
QueuedMeshUpdate();
|
||||||
|
~QueuedMeshUpdate();
|
||||||
|
};
|
||||||
|
|
||||||
|
/*
|
||||||
|
A thread-safe queue of mesh update tasks and a cache of MapBlock data
|
||||||
|
*/
|
||||||
|
class MeshUpdateQueue
|
||||||
|
{
|
||||||
|
enum UpdateMode {
|
||||||
|
FORCE_UPDATE,
|
||||||
|
SKIP_UPDATE_IF_ALREADY_CACHED,
|
||||||
|
};
|
||||||
|
public:
|
||||||
|
MeshUpdateQueue(Client *client);
|
||||||
|
|
||||||
|
~MeshUpdateQueue();
|
||||||
|
|
||||||
|
// Caches the block at p and its neighbors (if needed) and queues a mesh
|
||||||
|
// update for the block at p
|
||||||
|
void addBlock(Map *map, v3s16 p, bool ack_block_to_server, bool urgent);
|
||||||
|
|
||||||
|
// Returned pointer must be deleted
|
||||||
|
// Returns NULL if queue is empty
|
||||||
|
QueuedMeshUpdate * pop();
|
||||||
|
|
||||||
|
u32 size()
|
||||||
|
{
|
||||||
|
MutexAutoLock lock(m_mutex);
|
||||||
|
return m_queue.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Client *m_client;
|
||||||
|
std::vector<QueuedMeshUpdate*> m_queue;
|
||||||
|
std::set<v3s16> m_urgents;
|
||||||
|
std::map<v3s16, CachedMapBlockData*> m_cache;
|
||||||
|
Mutex m_mutex;
|
||||||
|
|
||||||
|
// TODO: Add callback to update these when g_settings changes
|
||||||
|
bool m_cache_enable_shaders;
|
||||||
|
bool m_cache_use_tangent_vertices;
|
||||||
|
bool m_cache_smooth_lighting;
|
||||||
|
int m_meshgen_block_cache_size;
|
||||||
|
|
||||||
|
CachedMapBlockData* cacheBlock(Map *map, v3s16 p, UpdateMode mode,
|
||||||
|
size_t *cache_hit_counter=NULL);
|
||||||
|
CachedMapBlockData* getCachedBlock(const v3s16 &p);
|
||||||
|
void fillDataFromMapBlockCache(QueuedMeshUpdate *q);
|
||||||
|
void cleanupCache();
|
||||||
|
};
|
||||||
|
|
||||||
|
struct MeshUpdateResult
|
||||||
|
{
|
||||||
|
v3s16 p;
|
||||||
|
MapBlockMesh *mesh;
|
||||||
|
bool ack_block_to_server;
|
||||||
|
|
||||||
|
MeshUpdateResult():
|
||||||
|
p(-1338,-1338,-1338),
|
||||||
|
mesh(NULL),
|
||||||
|
ack_block_to_server(false)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class MeshUpdateThread : public UpdateThread
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
MeshUpdateThread(Client *client);
|
||||||
|
|
||||||
|
// Caches the block at p and its neighbors (if needed) and queues a mesh
|
||||||
|
// update for the block at p
|
||||||
|
void updateBlock(Map *map, v3s16 p, bool ack_block_to_server, bool urgent);
|
||||||
|
|
||||||
|
v3s16 m_camera_offset;
|
||||||
|
MutexedQueue<MeshUpdateResult> m_queue_out;
|
||||||
|
|
||||||
|
private:
|
||||||
|
MeshUpdateQueue m_queue_in;
|
||||||
|
|
||||||
|
// TODO: Add callback to update these when g_settings changes
|
||||||
|
int m_generation_interval;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
virtual void doUpdate();
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif
|
Loading…
Reference in New Issue
Block a user