Relintai/voxelman
1
0
Fork 0
mirror of https://github.com/Relintai/voxelman.git synced 2024-11-12 10:15:12 +01:00
Code Issues Packages Projects Releases Wiki Activity

gdscript->c++ conversions.

Browse Source
This commit is contained in:
Relintai 2019-11-19 14:42:21 +01:00
parent 0594215929
commit d2566ab82b
6 changed files with 191 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
level_generator/voxelman_level_generator.cpp
View File

@ -1,5 +1,14 @@
#include "voxelman_level_generator.h"
void VoxelmanLevelGenerator::generate_chunk_bind(Node *chunk) {
generate_chunk(Object::cast_to<VoxelChunk>(chunk));
}
void VoxelmanLevelGenerator::generate_chunk(VoxelChunk *chunk) {
if (has_method("_generate_chunk")) {
call("_generate_chunk", chunk);
}
}
VoxelmanLevelGenerator::VoxelmanLevelGenerator() {
}
@ -7,4 +16,7 @@ VoxelmanLevelGenerator::~VoxelmanLevelGenerator() {
}
void VoxelmanLevelGenerator::_bind_methods() {
BIND_VMETHOD(MethodInfo("_generate_chunk", PropertyInfo(Variant::OBJECT, "chunk", PROPERTY_HINT_RESOURCE_TYPE, "VoxelChunk")));
ClassDB::bind_method(D_METHOD("generate_chunk", "chunk"), &VoxelmanLevelGenerator::generate_chunk_bind);
}

5
level_generator/voxelman_level_generator.h
View File

@ -3,10 +3,15 @@
#include "core/resource.h"
#include "../world/voxel_chunk.h"
class VoxelmanLevelGenerator : public Resource {
GDCLASS(VoxelmanLevelGenerator, Resource);
public:
void generate_chunk_bind(Node *chunk);
void generate_chunk(VoxelChunk *chunk);
VoxelmanLevelGenerator();
~VoxelmanLevelGenerator();

16
world/voxel_chunk.cpp
View File

@ -2,6 +2,13 @@
#include "voxel_world.h"
_FORCE_INLINE_ bool VoxelChunk::get_is_generating() const {
return _is_generating;
}
_FORCE_INLINE_ void VoxelChunk::set_is_generating(bool value) {
_is_generating = value;
}
_FORCE_INLINE_ bool VoxelChunk::get_dirty() const {
return _dirty;
}
@ -457,6 +464,8 @@ void VoxelChunk::finalize_mesh() {
void VoxelChunk::build() {
if (_current_build_phase == BUILD_PHASE_DONE) {
_is_generating = true;
next_phase();
}
}
@ -566,6 +575,8 @@ void VoxelChunk::next_phase() {
if (_current_build_phase >= BUILD_PHASE_MAX) {
_current_build_phase = BUILD_PHASE_DONE;
_is_generating = false;
emit_signal("mesh_generation_finished", this);
return;
@ -1046,6 +1057,7 @@ void VoxelChunk::free_chunk() {
}
VoxelChunk::VoxelChunk() {
_is_generating = false;
_dirty = false;
_state = VOXEL_CHUNK_STATE_OK;
@ -1104,6 +1116,10 @@ void VoxelChunk::_bind_methods() {
ClassDB::bind_method(D_METHOD("_create_mesher"), &VoxelChunk::_create_mesher);
ClassDB::bind_method(D_METHOD("get_is_generating"), &VoxelChunk::get_is_generating);
ClassDB::bind_method(D_METHOD("set_is_generating", "value"), &VoxelChunk::set_is_generating);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_generating"), "set_is_generating", "get_is_generating");
ClassDB::bind_method(D_METHOD("get_dirty"), &VoxelChunk::get_dirty);
ClassDB::bind_method(D_METHOD("set_dirty", "value"), &VoxelChunk::set_dirty);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "dirty"), "set_dirty", "get_dirty");

4
world/voxel_chunk.h
View File

@ -76,6 +76,9 @@ public:
};
public:
bool get_is_generating() const;
void set_is_generating(bool value);
bool get_dirty() const;
void set_dirty(bool value);
@ -254,6 +257,7 @@ public:
protected:
static void _bind_methods();
bool _is_generating;
bool _dirty;
int _state;

129
world/voxel_world.cpp
View File

@ -23,6 +23,27 @@ void VoxelWorld::set_chunk_size_z(const int value) {
_chunk_size_z = value;
}
int VoxelWorld::get_current_seed() const {
return _current_seed;
}
void VoxelWorld::set_current_seed(const int value) {
_current_seed = value;
}
bool VoxelWorld::get_use_threads() {
return _use_threads;
}
void VoxelWorld::set_use_threads(bool value) {
_use_threads = OS::get_singleton()->can_use_threads() ? value : false;
}
uint32_t VoxelWorld::get_max_concurrent_generations() {
return _max_concurrent_generations;
}
void VoxelWorld::set_max_concurrent_generations(uint32_t value) {
_max_concurrent_generations = OS::get_singleton()->can_use_threads() ? value : 1;
}
Ref<VoxelmanLibrary> VoxelWorld::get_library() const {
return _library;
}
@ -142,10 +163,46 @@ void VoxelWorld::clear_chunks() {
_chunks.clear();
}
void VoxelWorld::create_chunk(int x, int y, int z) {
call("_create_chunk");
}
void VoxelWorld::_create_chunk(int x, int y, int z) {
}
void VoxelWorld::generate_chunk_bind(Node *p_chunk) {
generate_chunk(Object::cast_to<VoxelChunk>(p_chunk));
}
void VoxelWorld::generate_chunk(VoxelChunk *p_chunk) {
ERR_FAIL_COND(!ObjectDB::instance_validate(p_chunk));
p_chunk->set_is_generating(true);
if (has_method("_prepare_chunk_for_generation"))
call("_prepare_chunk_for_generation", p_chunk);
call("_generate_chunk", p_chunk);
}
void VoxelWorld::_generate_chunk(Node *p_chunk) {
VoxelChunk *chunk = Object::cast_to<VoxelChunk>(p_chunk);
ERR_FAIL_COND(!ObjectDB::instance_validate(chunk));
ERR_FAIL_COND(!_level_generator.is_valid());
_level_generator->generate_chunk(chunk);
}
VoxelWorld::VoxelWorld() {
_chunk_size_x = 16;
_chunk_size_y = 16;
_chunk_size_z = 16;
_current_seed = 0;
set_use_threads(true);
set_max_concurrent_generations(3);
_voxel_scale = 1;
_chunk_spawn_range = 4;
@ -160,9 +217,67 @@ VoxelWorld ::~VoxelWorld() {
_world_areas.clear();
_library.unref();
_level_generator.unref();
_player = NULL;
_generation_queue.clear();
_generating.clear();;
}
void VoxelWorld::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
set_process_internal(false);
if (!Engine::get_singleton()->is_editor_hint() && _library.is_valid())
_library->refresh_rects();
}
case NOTIFICATION_INTERNAL_PROCESS: {
if (_generation_queue.empty() && _generating.empty()) {
call("_generation_finished");
emit_signal("generation_finished");
set_process_internal(false);
return;
}
for (int i = 0; i < _generating.size(); ++i) {
VoxelChunk *chunk = _generating.get(i);
if (!ObjectDB::instance_validate(chunk) || chunk->get_is_generating()) {
_generating.remove(i);
--i;
continue;
}
}
if (_generating.size() >= _max_concurrent_generations)
return;
if (_generation_queue.size == 0)
return;
VoxelChunk *chunk = _generation_queue.get(0);
_generation_queue.remove(0);
ERR_FAIL_COND(!ObjectDB::instance_validate(chunk));
_generating.push_back(chunk);
generate_chunk(chunk);
}
}
}
void VoxelWorld::_bind_methods() {
ADD_SIGNAL(MethodInfo("generation_finished"));
BIND_VMETHOD(MethodInfo("_generation_finished"));
BIND_VMETHOD(MethodInfo("_prepare_chunk_for_generation", PropertyInfo(Variant::OBJECT, "chunk", PROPERTY_HINT_RESOURCE_TYPE, "VoxelChunk")));
BIND_VMETHOD(MethodInfo("_generate_chunk", PropertyInfo(Variant::OBJECT, "chunk", PROPERTY_HINT_RESOURCE_TYPE, "VoxelChunk")));
ClassDB::bind_method(D_METHOD("get_chunk_size_x"), &VoxelWorld::get_chunk_size_x);
ClassDB::bind_method(D_METHOD("set_chunk_size_x", "value"), &VoxelWorld::set_chunk_size_x);
ADD_PROPERTY(PropertyInfo(Variant::INT, "chunk_size_x"), "set_chunk_size_x", "get_chunk_size_x");
@ -175,6 +290,18 @@ void VoxelWorld::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_chunk_size_z", "value"), &VoxelWorld::set_chunk_size_z);
ADD_PROPERTY(PropertyInfo(Variant::INT, "chunk_size_z"), "set_chunk_size_z", "get_chunk_size_z");
ClassDB::bind_method(D_METHOD("get_current_seed"), &VoxelWorld::get_current_seed);
ClassDB::bind_method(D_METHOD("set_current_seed", "value"), &VoxelWorld::set_current_seed);
ADD_PROPERTY(PropertyInfo(Variant::INT, "current_seed"), "set_current_seed", "get_current_seed");
ClassDB::bind_method(D_METHOD("get_use_threads"), &VoxelWorld::get_use_threads);
ClassDB::bind_method(D_METHOD("set_use_threads", "value"), &VoxelWorld::set_use_threads);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_threads"), "set_use_threads", "get_use_threads");
ClassDB::bind_method(D_METHOD("get_max_concurrent_generations"), &VoxelWorld::get_max_concurrent_generations);
ClassDB::bind_method(D_METHOD("set_max_concurrent_generations", "value"), &VoxelWorld::set_max_concurrent_generations);
ADD_PROPERTY(PropertyInfo(Variant::INT, "max_concurrent_generations"), "set_max_concurrent_generations", "get_max_concurrent_generations");
ClassDB::bind_method(D_METHOD("get_library"), &VoxelWorld::get_library);
ClassDB::bind_method(D_METHOD("set_library", "library"), &VoxelWorld::set_library);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "VoxelmanLibrary"), "set_library", "get_library");
@ -213,4 +340,6 @@ void VoxelWorld::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_chunk_count"), &VoxelWorld::get_chunk_count);
ClassDB::bind_method(D_METHOD("clear_chunks"), &VoxelWorld::clear_chunks);
ClassDB::bind_method(D_METHOD("generate_chunk", "chunk"), &VoxelWorld::generate_chunk_bind);
}

25
world/voxel_world.h
View File

@ -8,6 +8,8 @@
#include "../level_generator/voxelman_level_generator.h"
#include "../areas/world_area.h"
#include "core/os/os.h"
class VoxelChunk;
class VoxelWorld : public Navigation {
@ -22,6 +24,15 @@ public:
int get_chunk_size_z() const;
void set_chunk_size_z(const int value);
int get_current_seed() const;
void set_current_seed(const int value);
bool get_use_threads();
void set_use_threads(bool value);
uint32_t get_max_concurrent_generations();
void set_max_concurrent_generations(uint32_t value);
Ref<VoxelmanLibrary> get_library() const;
void set_library(const Ref<VoxelmanLibrary> library);
@ -58,10 +69,18 @@ public:
void clear_chunks();
void create_chunk(int x, int y, int z);
void _create_chunk(int x, int y, int z);
void generate_chunk_bind(Node *p_chunk);
void generate_chunk(VoxelChunk *p_chunk);
void _generate_chunk(Node *p_chunk);
VoxelWorld();
~VoxelWorld();
protected:
virtual void _notification(int p_what);
static void _bind_methods();
public:
@ -95,6 +114,7 @@ private:
int _chunk_size_x;
int _chunk_size_y;
int _chunk_size_z;
int _current_seed;
Ref<VoxelmanLibrary> _library;
Ref<VoxelmanLevelGenerator> _level_generator;
@ -108,6 +128,11 @@ private:
NodePath _player_path;
Spatial *_player;
bool _use_threads;
uint32_t _max_concurrent_generations;
Vector<VoxelChunk *> _generation_queue;
Vector<VoxelChunk *> _generating;
};
_FORCE_INLINE_ bool operator==(const VoxelWorld::IntPos &a, const VoxelWorld::IntPos &b) {