Relintai/godot_voxel
1
0
Fork 0
mirror of https://github.com/Relintai/godot_voxel.git synced 2024-11-11 20:35:08 +01:00
Code Issues Packages Projects Releases Wiki Activity

Blocks updates can be sorted by distance to viewer

Browse Source
This commit is contained in:
Marc Gilleron 2017-03-28 00:56:01 +02:00
parent ef4d07ca03
commit 4a24e28fce
3 changed files with 102 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
vector3i.h
View File

@ -45,6 +45,8 @@ struct Vector3i {
return Math::sqrt((real_t)length_sq());
}
_FORCE_INLINE_ int distance_sq(const Vector3i & other) const;
_FORCE_INLINE_ Vector3i & operator=(const Vector3i & other) {
x = other.x;
y = other.y;
@ -136,6 +138,10 @@ _FORCE_INLINE_ bool operator!=(const Vector3i & a, const Vector3i & b) {
return a.x != b.x && a.y != b.y && a.z != b.z;
}
_FORCE_INLINE_ int Vector3i::distance_sq(const Vector3i & other) const {
return (other - *this).length_sq();
}
struct Vector3iHasher {
static _FORCE_INLINE_ uint32_t hash(const Vector3i & v) {
uint32_t hash = hash_djb2_one_32(v.x);

110
voxel_terrain.cpp
View File

@ -9,11 +9,12 @@ VoxelTerrain::VoxelTerrain(): Node(), _min_y(-4), _max_y(4), _generate_collision
_mesher = Ref<VoxelMesher>(memnew(VoxelMesher));
}
// Sorts distance to world origin
// TODO Use distance to camera
struct BlockUpdateComparator0 {
Vector3i g_viewer_block_pos; // TODO UGLY! Lambdas or pointers needed...
// Sorts distance to viewer
struct BlockUpdateComparator {
inline bool operator()(const Vector3i & a, const Vector3i & b) const {
return a.length_sq() > b.length_sq();
return a.distance_sq(g_viewer_block_pos) > b.distance_sq(g_viewer_block_pos);
}
};
@ -33,24 +34,47 @@ void VoxelTerrain::set_generate_collisions(bool enabled) {
_generate_collisions = enabled;
}
void VoxelTerrain::force_load_blocks(Vector3i center, Vector3i extents) {
//Vector3i min = center - extents;
//Vector3i max = center + extents + Vector3i(1,1,1);
//Vector3i size = max - min;
void VoxelTerrain::set_viewer_path(NodePath path) {
if(!path.is_empty())
ERR_FAIL_COND(get_viewer(path) == NULL);
_viewer_path = path;
}
_block_update_queue.clear();
NodePath VoxelTerrain::get_viewer_path() {
return _viewer_path;
}
Spatial * VoxelTerrain::get_viewer(NodePath path) {
if(path.is_empty())
return NULL;
Node * node = get_node(path);
if(node == NULL)
return NULL;
return node->cast_to<Spatial>();
}
//void VoxelTerrain::clear_update_queue() {
// _block_update_queue.clear();
// _dirty_blocks.clear();
//}
void VoxelTerrain::make_block_dirty(Vector3i bpos) {
if(_dirty_blocks.has(bpos) == false) {
_block_update_queue.push_back(bpos);
_dirty_blocks[bpos] = true;
}
}
void VoxelTerrain::make_blocks_dirty(Vector3i min, Vector3i size) {
Vector3i max = min + size;
Vector3i pos;
for (pos.z = -extents.z; pos.z <= extents.z; ++pos.z) {
for (pos.x = -extents.x; pos.x <= extents.x; ++pos.x) {
for (pos.y = -extents.y; pos.y <= extents.y; ++pos.y) {
_block_update_queue.push_back(pos);
for(pos.z = min.z; pos.z < max.z; ++pos.z) {
for(pos.y = min.y; pos.y < max.y; ++pos.y) {
for(pos.x = min.x; pos.x < max.x; ++pos.x) {
make_block_dirty(pos);
}
}
}
_block_update_queue.sort_custom<BlockUpdateComparator0>();
}
int VoxelTerrain::get_block_update_count() {
@ -87,12 +111,23 @@ void VoxelTerrain::update_blocks() {
uint32_t time_before = os.get_ticks_msec();
uint32_t max_time = 1000 / 60;
// Get viewer location
Spatial * viewer = get_viewer(_viewer_path);
if(viewer)
g_viewer_block_pos = VoxelMap::voxel_to_block(viewer->get_translation());
else
g_viewer_block_pos = Vector3i();
// Sort updates so nearest blocks are done first
_block_update_queue.sort_custom<BlockUpdateComparator>();
// Update a bunch of blocks until none are left or too much time elapsed
while (!_block_update_queue.empty() && (os.get_ticks_msec() - time_before) < max_time) {
//printf("Remaining: %i\n", _block_update_queue.size());
// TODO Move this to a thread
// TODO Have VoxelTerrainGenerator in C++
// TODO Keep track of MeshInstances!
// Get request
Vector3i block_pos = _block_update_queue[_block_update_queue.size() - 1];
@ -132,6 +167,7 @@ void VoxelTerrain::update_blocks() {
// Pop request
_block_update_queue.resize(_block_update_queue.size() - 1);
_dirty_blocks.erase(block_pos);
}
}
@ -149,30 +185,13 @@ void VoxelTerrain::update_block_mesh(Vector3i block_pos) {
nbuffer.create(VoxelBlock::SIZE + 2, VoxelBlock::SIZE + 2, VoxelBlock::SIZE + 2);
_map->get_buffer_copy(VoxelMap::block_to_voxel(block_pos) - Vector3i(1, 1, 1), nbuffer);
// TEST
//if (block_pos == Vector3i(0, 0, 0)) {
// printf(">>>\n");
// String os;
// for (unsigned int y = 0; y < nbuffer.get_size().y; ++y) {
// for (unsigned int z = 0; z < nbuffer.get_size().z; ++z) {
// for (unsigned int x = 0; x < nbuffer.get_size().x; ++x) {
// if (nbuffer.get_voxel(x, y, z) == 0)
// os += '-';
// else
// os += 'O';
// }
// os += '\n';
// }
// os += '\n';
// }
// wprintf(os.c_str());
//}
Vector3 block_node_pos = VoxelMap::block_to_voxel(block_pos).to_vec3();
// Build mesh (that part is the most CPU-intensive)
Ref<Mesh> mesh = _mesher->build(nbuffer);
// TODO Don't use nodes! Use servers directly, it's faster
MeshInstance * mesh_instance = block->get_mesh_instance(*this);
if (mesh_instance == NULL) {
// Create and spawn mesh
@ -185,7 +204,6 @@ void VoxelTerrain::update_block_mesh(Vector3i block_pos) {
else {
// Update mesh
mesh_instance->set_mesh(mesh);
}
if(get_tree()->is_editor_hint() == false && _generate_collisions) {
@ -256,6 +274,18 @@ Variant VoxelTerrain::_raycast_binding(Vector3 origin, Vector3 direction, real_t
}
}
//void VoxelTerrain::set_voxel_immediate(Vector3 pos, int value, int c) {
// Vector3i vpos = pos;
// _map->set_voxel(value, vpos, c);
//}
//int VoxelTerrain::get_voxel(Vector3 pos, int c) {
// return _map->get_voxel(pos, c);
//}
void VoxelTerrain::_bind_methods() {
@ -268,13 +298,17 @@ void VoxelTerrain::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_generate_collisions"), &VoxelTerrain::get_generate_collisions);
ClassDB::bind_method(D_METHOD("set_generate_collisions", "enabled"), &VoxelTerrain::set_generate_collisions);
ClassDB::bind_method(D_METHOD("get_viewer"), &VoxelTerrain::get_viewer_path);
ClassDB::bind_method(D_METHOD("set_viewer", "path"), &VoxelTerrain::set_viewer_path);
ClassDB::bind_method(D_METHOD("get_map:VoxelMap"), &VoxelTerrain::get_map);
// TODO Make those two static in VoxelMap?
ClassDB::bind_method(D_METHOD("voxel_to_block", "voxel_pos"), &VoxelTerrain::_voxel_to_block_binding);
ClassDB::bind_method(D_METHOD("block_to_voxel", "block_pos"), &VoxelTerrain::_block_to_voxel_binding);
ClassDB::bind_method(D_METHOD("force_load_blocks", "center", "extents"), &VoxelTerrain::_force_load_blocks_binding);
ClassDB::bind_method(D_METHOD("make_block_dirty", "pos"), &VoxelTerrain::_make_block_dirty_binding);
ClassDB::bind_method(D_METHOD("make_blocks_dirty", "min", "size"), &VoxelTerrain::_make_blocks_dirty_binding);
ClassDB::bind_method(D_METHOD("raycast:Dictionary", "origin", "direction", "max_distance"), &VoxelTerrain::_raycast_binding, DEFVAL(100));

24
voxel_terrain.h
View File

@ -21,21 +21,32 @@ public:
void force_load_blocks(Vector3i center, Vector3i extents);
int get_block_update_count();
//void clear_update_queue();
void make_block_dirty(Vector3i bpos);
void make_blocks_dirty(Vector3i min, Vector3i size);
void set_generate_collisions(bool enabled);
bool get_generate_collisions() { return _generate_collisions; }
void set_viewer_path(NodePath path);
NodePath get_viewer_path();
Ref<VoxelMesher> get_mesher() { return _mesher; }
Ref<VoxelMap> get_map() { return _map; }
Ref<VoxelLibrary> get_voxel_library();
protected:
void _notification(int p_what);
private:
void _process();
void update_blocks();
void update_block_mesh(Vector3i block_pos);
Spatial * get_viewer(NodePath path);
// Observer events
//void block_removed(VoxelBlock & block);
@ -45,8 +56,14 @@ protected:
Vector3 _voxel_to_block_binding(Vector3 pos) { return Vector3i(VoxelMap::voxel_to_block(pos)).to_vec3(); }
Vector3 _block_to_voxel_binding(Vector3 pos) { return Vector3i(VoxelMap::block_to_voxel(pos)).to_vec3(); }
void _force_load_blocks_binding(Vector3 center, Vector3 extents) { force_load_blocks(center, extents); }
void _make_block_dirty_binding(Vector3 bpos) { make_block_dirty(bpos); }
void _make_blocks_dirty_binding(Vector3 min, Vector3 size) { make_blocks_dirty(min, size); }
Variant _raycast_binding(Vector3 origin, Vector3 direction, real_t max_distance);
// void set_voxel(Vector3 pos, int value, int c);
// int get_voxel(Vector3 pos, int c);
private:
// Parameters
int _min_y; // In blocks, not voxels
@ -55,10 +72,17 @@ private:
// Voxel storage
Ref<VoxelMap> _map;
// TODO Terrains only need to handle the visible portion of voxels, which reduces the bounds blocks to handle.
// Therefore, could a simple grid be better to use than a hashmap?
Vector<Vector3i> _block_update_queue;
HashMap<Vector3i, bool, Vector3iHasher> _dirty_blocks; // only the key is relevant
Ref<VoxelMesher> _mesher;
Ref<VoxelProvider> _provider;
NodePath _viewer_path;
bool _generate_collisions;
};