Zylann
/
godot_voxel
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Moved Godot-facing block serializer API to its own file

master
Marc Gilleron 2022-02-12 23:52:44 +00:00
parent b3faec2bef
commit 4c36b96ef2
4 changed files with 53 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
register_types.cpp
View File

@ -24,6 +24,7 @@
#include "streams/region/voxel_stream_region_files.h"
#include "streams/sqlite/voxel_stream_sqlite.h"
#include "streams/vox_loader.h"
#include "streams/voxel_block_serializer_gd.h"
#include "streams/voxel_stream_block_files.h"
#include "streams/voxel_stream_script.h"
#include "terrain/instancing/voxel_instance_component.h"
@ -126,7 +127,7 @@ void register_voxel_types() {
// I had to bind this one despite it being useless as-is because otherwise Godot lazily initializes its class.
// And this can happen in a thread, causing crashes due to the concurrent access
ClassDB::register_virtual_class<VoxelToolBuffer>();
ClassDB::register_class<VoxelBlockSerializer>();
ClassDB::register_class<gd::VoxelBlockSerializer>();
ClassDB::register_class<VoxelVoxLoader>();
ClassDB::register_class<FastNoiseLite>();
ClassDB::register_class<FastNoiseLiteGradient>();

35
streams/voxel_block_serializer.cpp
View File

@ -13,7 +13,6 @@
#include <limits>
namespace zylann::voxel {
namespace BlockSerializer {
const uint8_t BLOCK_FORMAT_VERSION = 2;
@ -432,26 +431,26 @@ bool decompress_and_deserialize(FileAccess *f, unsigned int size_to_read, VoxelB
return decompress_and_deserialize(to_span_const(compressed_data), out_voxel_buffer);
}
int serialize(Ref<StreamPeer> peer, VoxelBufferInternal &voxel_buffer, bool compress) {
int serialize(StreamPeer &peer, VoxelBufferInternal &voxel_buffer, bool compress) {
if (compress) {
SerializeResult res = serialize_and_compress(voxel_buffer);
ERR_FAIL_COND_V(!res.success, -1);
peer->put_data(res.data.data(), res.data.size());
peer.put_data(res.data.data(), res.data.size());
return res.data.size();
} else {
SerializeResult res = serialize(voxel_buffer);
ERR_FAIL_COND_V(!res.success, -1);
peer->put_data(res.data.data(), res.data.size());
peer.put_data(res.data.data(), res.data.size());
return res.data.size();
}
}
void deserialize(Ref<StreamPeer> peer, VoxelBufferInternal &voxel_buffer, int size, bool decompress) {
void deserialize(StreamPeer &peer, VoxelBufferInternal &voxel_buffer, int size, bool decompress) {
if (decompress) {
std::vector<uint8_t> &compressed_data = tls_compressed_data;
compressed_data.resize(size);
const Error err = peer->get_data(compressed_data.data(), compressed_data.size());
const Error err = peer.get_data(compressed_data.data(), compressed_data.size());
ERR_FAIL_COND(err != OK);
bool success = decompress_and_deserialize(to_span_const(compressed_data), voxel_buffer);
ERR_FAIL_COND(!success);
@ -459,33 +458,11 @@ void deserialize(Ref<StreamPeer> peer, VoxelBufferInternal &voxel_buffer, int si
} else {
std::vector<uint8_t> &data = tls_data;
data.resize(size);
const Error err = peer->get_data(data.data(), data.size());
const Error err = peer.get_data(data.data(), data.size());
ERR_FAIL_COND(err != OK);
deserialize(to_span_const(data), voxel_buffer);
}
}
} // namespace BlockSerializer
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int VoxelBlockSerializer::serialize(Ref<StreamPeer> peer, Ref<VoxelBuffer> voxel_buffer, bool compress) {
ERR_FAIL_COND_V(voxel_buffer.is_null(), 0);
ERR_FAIL_COND_V(peer.is_null(), 0);
return BlockSerializer::serialize(peer, voxel_buffer->get_buffer(), compress);
}
void VoxelBlockSerializer::deserialize(Ref<StreamPeer> peer, Ref<VoxelBuffer> voxel_buffer, int size, bool decompress) {
ERR_FAIL_COND(voxel_buffer.is_null());
ERR_FAIL_COND(peer.is_null());
ERR_FAIL_COND(size <= 0);
BlockSerializer::deserialize(peer, voxel_buffer->get_buffer(), size, decompress);
}
void VoxelBlockSerializer::_bind_methods() {
ClassDB::bind_method(D_METHOD("serialize", "peer", "voxel_buffer", "compress"), &VoxelBlockSerializer::serialize);
ClassDB::bind_method(
D_METHOD("deserialize", "peer", "voxel_buffer", "size", "decompress"), &VoxelBlockSerializer::deserialize);
}
} // namespace zylann::voxel

19
streams/voxel_block_serializer.h
View File

@ -4,7 +4,6 @@
#include "../util/span.h"
#include <core/io/file_access_memory.h>
#include <core/object/ref_counted.h>
#include <vector>
class StreamPeer;
@ -31,24 +30,10 @@ SerializeResult serialize_and_compress(const VoxelBufferInternal &voxel_buffer);
bool decompress_and_deserialize(Span<const uint8_t> p_data, VoxelBufferInternal &out_voxel_buffer);
bool decompress_and_deserialize(FileAccess *f, unsigned int size_to_read, VoxelBufferInternal &out_voxel_buffer);
int serialize(Ref<StreamPeer> peer, VoxelBufferInternal &voxel_buffer, bool compress);
void deserialize(Ref<StreamPeer> peer, VoxelBufferInternal &voxel_buffer, int size, bool decompress);
int serialize(StreamPeer &peer, VoxelBufferInternal &voxel_buffer, bool compress);
void deserialize(StreamPeer &peer, VoxelBufferInternal &voxel_buffer, int size, bool decompress);
} // namespace BlockSerializer
class VoxelBuffer;
// Godot-facing API for BlockSerializer
class VoxelBlockSerializer : public RefCounted {
GDCLASS(VoxelBlockSerializer, RefCounted)
public:
int serialize(Ref<StreamPeer> peer, Ref<VoxelBuffer> voxel_buffer, bool compress);
void deserialize(Ref<StreamPeer> peer, Ref<VoxelBuffer> voxel_buffer, int size, bool decompress);
private:
static void _bind_methods();
};
} // namespace zylann::voxel
#endif // VOXEL_BLOCK_SERIALIZER_H

43
streams/voxel_block_serializer_gd.h Normal file
View File

@ -0,0 +1,43 @@
#ifndef VOXEL_BLOCK_SERIALIZER_GD_H
#define VOXEL_BLOCK_SERIALIZER_GD_H
#include "../storage/voxel_buffer.h"
#include "voxel_block_serializer.h"
namespace zylann::voxel {
class VoxelBuffer;
namespace gd {
// Godot-facing API for BlockSerializer
// TODO Could be a singleton? Or methods on VoxelBuffer? This object has no state.
class VoxelBlockSerializer : public RefCounted {
GDCLASS(VoxelBlockSerializer, RefCounted)
public:
int serialize(Ref<StreamPeer> peer, Ref<VoxelBuffer> voxel_buffer, bool compress) {
ERR_FAIL_COND_V(voxel_buffer.is_null(), 0);
ERR_FAIL_COND_V(peer.is_null(), 0);
return BlockSerializer::serialize(**peer, voxel_buffer->get_buffer(), compress);
}
void deserialize(Ref<StreamPeer> peer, Ref<VoxelBuffer> voxel_buffer, int size, bool decompress) {
ERR_FAIL_COND(voxel_buffer.is_null());
ERR_FAIL_COND(peer.is_null());
ERR_FAIL_COND(size <= 0);
BlockSerializer::deserialize(**peer, voxel_buffer->get_buffer(), size, decompress);
}
private:
static void _bind_methods() {
ClassDB::bind_method(
D_METHOD("serialize", "peer", "voxel_buffer", "compress"), &VoxelBlockSerializer::serialize);
ClassDB::bind_method(D_METHOD("deserialize", "peer", "voxel_buffer", "size", "decompress"),
&VoxelBlockSerializer::deserialize);
}
};
} // namespace gd
} // namespace zylann::voxel
#endif // VOXEL_BLOCK_SERIALIZER_GD_H