41#include <fmt/format.h>
46# include <openvdb/io/Stream.h>
47# include <openvdb/openvdb.h>
54using namespace io::serialize;
77 auto io_slice = std::make_shared<DictionaryValue>();
78 io_slice->append_str(
"name", this->
name);
80 io_slice->append_int(
"size",
range.
size());
86 const std::optional<StringRefNull>
name = io_slice.
lookup_str(
"name");
87 const std::optional<int64_t> start = io_slice.
lookup_int(
"start");
88 const std::optional<int64_t> size = io_slice.
lookup_int(
"size");
89 if (!
name || !start || !size) {
99 std::ostringstream stream{std::ios::binary};
101 std::string
data = stream.rdbuf()->str();
110 if (!this->
read(slice, buffer.data())) {
113 std::istringstream stream{buffer, std::ios::binary};
129 BLI_path_join(blob_path,
sizeof(blob_path), blobs_dir_.c_str(), slice.
name.c_str());
131 std::lock_guard
lock{mutex_};
132 std::unique_ptr<fstream> &blob_file = open_input_streams_.lookup_or_add_cb_as(blob_path, [&]() {
133 return std::make_unique<fstream>(blob_path, std::ios::in | std::ios::binary);
136 blob_file->read(
static_cast<char *
>(r_data), slice.
range.
size());
137 if (blob_file->gcount() != slice.
range.
size()) {
144 : blob_dir_(std::move(blob_dir)), base_name_(std::move(base_name))
146 blob_name_ = base_name_ +
".blob";
151 if (!blob_stream_.is_open()) {
153 BLI_path_join(blob_path,
sizeof(blob_path), blob_dir_.c_str(), blob_name_.c_str());
155 blob_stream_.open(blob_path, std::ios::out | std::ios::binary);
158 const int64_t old_offset = current_offset_;
159 blob_stream_.write(
static_cast<const char *
>(
data), size);
160 current_offset_ += size;
162 return {blob_name_, {old_offset, size}};
166 const int file_index,
169 return fmt::format(
"{}_file_{}{}", base_name, file_index, extension);
176 independent_file_count_++;
178 base_name_, independent_file_count_, file_extension);
181 BLI_path_join(path,
sizeof(path), blob_dir_.c_str(), file_name.c_str());
183 std::fstream stream{path, std::ios::out | std::ios::binary};
185 const int64_t written_bytes_num = stream.tellg();
187 return {file_name, {0, written_bytes_num}};
192 blob_by_name_.add(name, blob);
205 memcpy(r_data, copy_src, slice.
range.
size());
211 blob_name_ = base_name_ +
".blob";
212 stream_by_name_.add(blob_name_, {std::make_unique<std::ostringstream>(std::ios::binary)});
217 OutputStream &stream = stream_by_name_.lookup(blob_name_);
219 stream.
stream->write(
static_cast<const char *
>(
data), size);
229 independent_file_count_++;
231 base_name_, independent_file_count_, file_extension);
232 OutputStream stream{std::make_unique<std::ostringstream>(std::ios::binary)};
235 stream_by_name_.add_new(name, std::move(stream));
243 sharing_info->remove_weak_user_and_delete_if_last();
250 if (value.sharing_info) {
251 value.sharing_info->remove_user_and_delete_if_last();
259 if (sharing_info ==
nullptr) {
262 return stored_by_runtime_.add_or_modify(
265 [&](StoredByRuntimeValue *value) {
266 new (value) StoredByRuntimeValue();
267 value->io_data = write_fn();
268 value->sharing_info_version = sharing_info->
version();
270 return value->io_data;
273 [&](StoredByRuntimeValue *value) {
275 BLI_assert(value->sharing_info_version <= new_version);
276 if (value->sharing_info_version < new_version) {
277 value->io_data = write_fn();
278 value->sharing_info_version = new_version;
280 return value->io_data;
287 const uint64_t content_hash = XXH3_64bits(
data, size_in_bytes);
288 const BlobSlice slice = slice_by_content_hash_.lookup_or_add_cb(
289 content_hash, [&]() {
return writer.
write(
data, size_in_bytes); });
295 FunctionRef<std::optional<ImplicitSharingInfoAndData>()> read_fn)
const
297 std::lock_guard
lock{mutex_};
300 std::stringstream ss;
302 const std::string key = ss.str();
305 shared_data->sharing_info->add_user();
308 std::optional<ImplicitSharingInfoAndData>
data = read_fn();
312 if (
data->sharing_info !=
nullptr) {
313 data->sharing_info->add_user();
314 runtime_by_stored_.add_new(key, *
data);
321 const char *io_name =
"unknown";
328 const char *io_name =
"unknown";
335 const char *io_name =
"unknown";
386 if (slice->range.size() != bytes_num) {
389 return blob_reader.
read(*slice, r_data);
424 const std::optional<ImplicitSharingInfoAndData> sharing_info_and_data = blob_sharing.
read_shared(
425 io_data, [&]() -> std::optional<ImplicitSharingInfoAndData> {
433 if (!sharing_info_and_data) {
434 *r_sharing_info =
nullptr;
437 *r_sharing_info = sharing_info_and_data->sharing_info;
438 return sharing_info_and_data->data;
450 io_data, blob_reader, blob_sharing,
CPPType::get<T>(), size, r_sharing_info)));
451 return *r_data !=
nullptr;
455 std::unique_ptr<BakeMaterialsList> &materials)
457 if (io_materials.
elements().is_empty()) {
460 materials = std::make_unique<BakeMaterialsList>();
461 for (
const auto &io_material_value : io_materials.
elements()) {
463 materials->append(std::nullopt);
466 const auto *io_material = io_material_value->as_dictionary_value();
470 std::optional<std::string> id_name = io_material->lookup_str(
"name");
474 std::string lib_name = io_material->lookup_str(
"lib_name").value_or(
"");
485 for (
const auto &io_attribute_value : io_attributes.
elements()) {
486 const auto *io_attribute = io_attribute_value->as_dictionary_value();
490 const std::optional<StringRefNull> name = io_attribute->lookup_str(
"name");
491 const std::optional<StringRefNull> domain_str = io_attribute->lookup_str(
"domain");
492 const std::optional<StringRefNull> type_str = io_attribute->lookup_str(
"type");
493 const auto *io_data = io_attribute->
lookup_dict(
"data");
494 if (!name || !domain_str || !type_str || !io_data) {
500 if (!domain || !data_type) {
509 if (
const std::optional<StringRefNull>
str = io_attribute->lookup_str(
"storage_type")) {
514 switch (storage_type) {
516 const int domain_size = attributes.
domain_size(*domain);
519 *io_data, blob_reader, blob_sharing, *cpp_type, domain_size, &attribute_sharing_info);
520 if (!attribute_data) {
537 if (!attributes.
add(*name,
550 *io_data, blob_reader, blob_sharing, *cpp_type, 1, &sharing_info);
580 if (!io_pointcloud) {
584 if (!io_attributes) {
589 const int points_num = io_pointcloud->
lookup_int(
"num_points").value_or(0);
592 auto cancel = [&]() {
598 if (!
load_attributes(*io_attributes, attributes, blob_reader, blob_sharing)) {
615 if (!io_attributes) {
620 curves.attribute_storage.wrap().remove(
"position");
624 if (
curves.curves_num() > 0) {
625 const auto *io_curve_offsets = io_curves.
lookup_dict(
"curve_offsets");
626 if (!io_curve_offsets) {
634 &
curves.runtime->curve_offsets_sharing_info))
641 if (!
load_attributes(*io_attributes, attributes, blob_reader, blob_sharing)) {
651 curves.update_curve_types();
665 if (!io_attributes) {
670 *io_curves, blob_reader, blob_sharing);
678 auto cancel = [&]() {
697 if (!io_grease_pencil) {
708 if (!io_layer_attributes) {
713 auto cancel = [&]() {
718 const int layers_num = io_layers->
elements().size();
719 grease_pencil->add_layers_with_empty_drawings_for_eval(layers_num);
721 for (
const int layer_i : io_layers->
elements().index_range()) {
722 const auto &io_layer_value = io_layers->
elements()[layer_i];
731 const std::optional<std::string> layer_name = io_layer->
lookup_str(
"name");
736 layer.set_name(*layer_name);
738 *io_strokes, blob_reader, blob_sharing);
747 if (!
load_attributes(*io_layer_attributes, attributes, blob_reader, blob_sharing)) {
753 if (!io_layer_opacities ||
762 *io_layer_blend_modes,
771 *io_layer_transforms,
777 for (
const int layer_i :
IndexRange(layers_num)) {
779 layer.opacity = layer_opacities[layer_i];
781 layer.set_local_transform(layer_transforms[layer_i]);
797 const auto reset_texspace_default = [](
Mesh *
mesh) {
798 std::ranges::fill(
mesh->texspace_location, 0.0f);
799 std::ranges::fill(
mesh->texspace_size, 1.0f);
803 float r_texspace_property[3]) ->
bool {
805 for (
const std::shared_ptr<Value> &value : io_array->
elements()) {
809 r_texspace_property[i++] =
float(value->as_double_value()->value());
814 mesh->texspace_flag = io_mesh->
lookup_bool(
"texture_space_flag").value_or(
false);
817 "texture_space_location");
820 if (!io_texloc_array || !io_texsize_array) {
821 reset_texspace_default(
mesh);
828 if (!fill_texspace_values(io_texloc_array,
mesh->texspace_location) ||
829 !fill_texspace_values(io_texsize_array,
mesh->texspace_size))
831 reset_texspace_default(
mesh);
846 if (!io_attributes) {
851 mesh->verts_num = io_mesh->
lookup_int(
"num_vertices").value_or(0);
853 mesh->faces_num = io_mesh->
lookup_int(
"num_polygons").value_or(0);
854 mesh->corners_num = io_mesh->
lookup_int(
"num_corners").value_or(0);
856 auto cancel = [&]() {
861 if (
mesh->faces_num > 0) {
862 const auto *io_poly_offsets = io_mesh->
lookup_dict(
"poly_offsets");
863 if (!io_poly_offsets) {
870 &
mesh->face_offset_indices,
871 &
mesh->runtime->face_offsets_sharing_info))
879 if (
const auto *io_attributes = io_mesh->
lookup_array(
"vertex_group_names")) {
880 for (
const std::shared_ptr<Value> &value : io_attributes->
elements()) {
884 bDeformGroup *defgroup = MEM_new<bDeformGroup>(__func__);
891 if (!
load_attributes(*io_attributes, attributes, blob_reader, blob_sharing)) {
903 if (
const std::optional<StringRefNull> default_uv_map_name = io_mesh->
lookup_str(
904 "default_uv_map_name"))
906 mesh->uv_maps_default_set(*default_uv_map_name);
908 if (
const std::optional<StringRefNull> default_color_attribute = io_mesh->
lookup_str(
909 "default_color_name"))
911 mesh->default_color_attribute =
BLI_strdupn(default_color_attribute->data(),
912 default_color_attribute->size());
919 const BlobReader &blob_reader,
920 const BlobReadSharing &blob_sharing);
930 const int num_instances = io_instances->
lookup_int(
"num_instances").value_or(0);
931 if (num_instances == 0) {
935 if (!io_attributes) {
939 if (!io_references) {
943 std::unique_ptr<Instances> instances = std::make_unique<Instances>(num_instances);
945 for (
const auto &io_reference_value : io_references->
elements()) {
949 reference_geometry =
load_geometry(*io_reference, blob_reader, blob_sharing);
951 instances->add_new_reference(std::move(reference_geometry));
955 if (!
load_attributes(*io_attributes, attributes, blob_reader, blob_sharing)) {
959 if (!attributes.
contains(
".reference_index")) {
962 const auto *io_handles = io_instances->
lookup_dict(
"handles");
967 blob_reader, *io_handles, instances->reference_handles_for_write()))
973 if (!attributes.
contains(
"instance_transform")) {
976 const auto *io_handles = io_instances->
lookup_dict(
"transforms");
989static Volume *try_load_volume(
const DictionaryValue &io_geometry,
const BlobReader &blob_reader)
991 const DictionaryValue *io_volume = io_geometry.lookup_dict(
"volume");
995 const auto *io_vdb = io_volume->lookup_dict(
"vdb");
999 openvdb::GridPtrVecPtr vdb_grids;
1001 if (!blob_reader.read_as_stream(*vdb_slice,
1002 [&](std::istream &stream) {
1004 openvdb::io::Stream vdb_stream{stream};
1005 vdb_grids = vdb_stream.getGrids();
1017 auto cancel = [&]() {
1022 for (openvdb::GridBase::Ptr &vdb_grid : *vdb_grids) {
1024 bke::GVolumeGrid grid{std::move(vdb_grid)};
1028 if (
const io::serialize::ArrayValue *io_materials = io_volume->lookup_array(
"materials")) {
1029 if (!
load_materials(*io_materials, volume->runtime->bake_materials)) {
1046 if (!io_bundle_items) {
1068 geometry.replace_volume(try_load_volume(io_geometry, blob_reader));
1075 const std::unique_ptr<BakeMaterialsList> &materials)
1077 auto io_materials = std::make_shared<io::serialize::ArrayValue>();
1079 return io_materials;
1081 for (
const std::optional<BakeDataBlockID> &material : *materials) {
1083 auto io_material = io_materials->append_dict();
1084 io_material->append_str(
"name", material->id_name);
1085 if (!material->lib_name.empty()) {
1086 io_material->append_str(
"lib_name", material->lib_name);
1090 io_materials->append_null();
1093 return io_materials;
1102 auto io_attributes = std::make_shared<io::serialize::ArrayValue>();
1109 auto io_attribute = io_attributes->append_dict();
1111 io_attribute->append_str(
"name", iter.
name);
1114 io_attribute->append_str(
"domain", domain_name);
1118 io_attribute->append_str(
"type", type_name);
1125 io_attribute->append(
"data",
1127 blob_writer, blob_sharing, attribute_span,
attribute.sharing_info));
1132 io_attribute->append(
"data",
1140 return io_attributes;
1151 if (
curves.curve_num > 0) {
1152 io_curves.
append(
"curve_offsets",
1156 curves.runtime->curve_offsets_sharing_info));
1160 io_curves.
append(
"attributes", io_attributes);
1165 io_mesh->append_bool(
"texture_space_flag",
mesh.texspace_flag);
1167 std::shared_ptr<ArrayValue> texspace_location_array = io_mesh->append_array(
1168 "texture_space_location");
1169 for (
float value :
Span(
mesh.texspace_location, 3)) {
1170 texspace_location_array->append_double(value);
1173 std::shared_ptr<ArrayValue> texspace_size_array = io_mesh->append_array(
"texture_space_size");
1174 for (
float value :
Span(
mesh.texspace_size, 3)) {
1175 texspace_size_array->append_double(value);
1183 auto io_geometry = std::make_shared<DictionaryValue>();
1186 auto io_mesh = io_geometry->append_dict(
"mesh");
1188 io_mesh->append_int(
"num_vertices",
mesh.verts_num);
1189 io_mesh->append_int(
"num_edges",
mesh.edges_num);
1190 io_mesh->append_int(
"num_polygons",
mesh.faces_num);
1191 io_mesh->append_int(
"num_corners",
mesh.corners_num);
1193 if (
mesh.faces_num > 0) {
1194 io_mesh->append(
"poly_offsets",
1197 mesh.face_offsets(),
1198 mesh.runtime->face_offsets_sharing_info));
1202 io_mesh->append(
"materials", io_materials);
1204 if (!
mesh.vertex_group_names.is_empty()) {
1205 auto io_vertex_group_names = io_mesh->append_array(
"vertex_group_names");
1207 io_vertex_group_names->append_str(defgroup.
name);
1213 const StringRef default_uv_map_name =
mesh.default_uv_map_name();
1214 if (!default_uv_map_name.
is_empty()) {
1215 io_mesh->append_str(
"default_uv_map_name", default_uv_map_name);
1217 const StringRef default_color_attribute =
mesh.default_color_attribute;
1218 if (!default_color_attribute.
is_empty()) {
1219 io_mesh->append_str(
"default_color_name", default_color_attribute);
1223 io_mesh->append(
"attributes", io_attributes);
1227 auto io_pointcloud = io_geometry->append_dict(
"pointcloud");
1229 io_pointcloud->append_int(
"type",
int(pointcloud.
type));
1230 io_pointcloud->append_int(
"num_points", pointcloud.
totpoint);
1233 io_pointcloud->append(
"materials", io_materials);
1236 pointcloud.attributes(), blob_writer, blob_sharing, {});
1237 io_pointcloud->append(
"attributes", io_attributes);
1243 auto io_curves = io_geometry->append_dict(
"curves");
1248 io_curves->append(
"materials", io_materials);
1250 if (
geometry.has_grease_pencil()) {
1252 auto io_grease_pencil = io_geometry->append_dict(
"grease_pencil");
1253 auto io_layers = io_grease_pencil->append_array(
"layers");
1259 auto io_layer = io_layers->append_dict();
1260 io_layer->append_str(
"name",
layer->name());
1261 auto io_strokes = io_layer->append_dict(
"strokes");
1272 layer_transforms.
append(
layer->local_transform());
1275 io_grease_pencil->
append(
1278 io_grease_pencil->append(
1281 io_grease_pencil->append(
1287 io_grease_pencil->append(
"layer_attributes", io_layer_attributes);
1290 io_grease_pencil->append(
"materials", io_materials);
1297 auto io_volume = io_geometry->append_dict(
"volume");
1298 auto io_vdb = blob_writer
1300 [&](std::ostream &stream) {
1301 openvdb::GridCPtrVec vdb_grids;
1307 vdb_grids.push_back(grid->grid_ptr(tree_tokens.
last()));
1310 openvdb::io::Stream vdb_stream(stream);
1311 vdb_stream.write(vdb_grids);
1314 io_volume->append(
"vdb", std::move(io_vdb));
1317 io_volume->append(
"materials", io_materials);
1322 auto io_instances = io_geometry->append_dict(
"instances");
1324 io_instances->append_int(
"num_instances", instances.
instances_num());
1326 auto io_references = io_instances->append_array(
"references");
1339 instances.
attributes(), blob_writer, blob_sharing, {});
1340 io_instances->append(
"attributes", io_attributes);
1344 auto io_bundle = io_geometry->append_dict(
"bundle");
1345 auto io_bundle_items = io_bundle->append_array(
"items");
1353 auto io_value = std::make_shared<io::serialize::ArrayValue>();
1354 for (
const float value : values) {
1355 io_value->append_double(value);
1362 auto io_value = std::make_shared<io::serialize::ArrayValue>();
1363 for (
const int value : values) {
1364 io_value->append_int(value);
1372 switch (data_type) {
1374 const float value = *
static_cast<const float *
>(value_ptr);
1375 return std::make_shared<io::serialize::DoubleValue>(value);
1378 const float2 value = *
static_cast<const float2 *
>(value_ptr);
1382 const float3 value = *
static_cast<const float3 *
>(value_ptr);
1386 const float4 value = *
static_cast<const float4 *
>(value_ptr);
1390 const bool value = *
static_cast<const bool *
>(value_ptr);
1391 return std::make_shared<io::serialize::BooleanValue>(value);
1394 const int value = *
static_cast<const int *
>(value_ptr);
1395 return std::make_shared<io::serialize::IntValue>(value);
1398 const int2 value =
int2(*
static_cast<const short2 *
>(value_ptr));
1402 const int2 value = *
static_cast<const int2 *
>(value_ptr);
1407 const int4 value_int{&value.
r};
1444 std::optional<T>
element =
fn(io_element);
1448 r_values[i] = std::move(*
element);
1457 return std::nullopt;
1460 if (value < std::numeric_limits<T>::lowest()) {
1461 return std::nullopt;
1463 if (value > std::numeric_limits<T>::max()) {
1464 return std::nullopt;
1472 return io_double->value();
1475 return io_int->value();
1477 return std::nullopt;
1490 static_assert(std::is_integral_v<T>);
1504 *
static_cast<float *
>(r_value) = *value;
1518 *
static_cast<bool *
>(r_value) = io_value_boolean->value();
1528 *
static_cast<int *
>(r_value) = *value;
1561 for (
const auto &io_item_ : io_bundle_items.
elements()) {
1566 const std::optional<std::string> key_str = io_item->
lookup_str(
"key");
1570 const std::optional<StringRefNull> socket_idname = io_item->
lookup_str(
"socket_idname");
1571 if (!socket_idname) {
1576 *io_item_value, blob_reader, blob_sharing);
1598 for (
const auto &item : bundle.
items()) {
1599 if (
const auto *socket_value = std::get_if<nodes::BundleItemSocketValue>(&item.value.value)) {
1601 io_bundle_item.
append_str(
"key", item.key.ustr().string());
1602 io_bundle_item.
append_str(
"socket_idname", socket_value->type->idname.string());
1605 socket_value->value, blob_writer, blob_sharing, io_bundle_item_value);
1625 r_io_item.
append(
"data", io_geometry);
1628 if (type.
is<std::string>()) {
1632 const int64_t blob_threshold = 100;
1633 if (
str.size() < blob_threshold) {
1655 r_io_item.
append(
"data", std::move(io_data));
1665 const StringRef attribute_name = attribute_field_input->attribute_name();
1670 r_io_item.
append_str(
"name", attribute_name);
1676static void serialize_volume_grid(
const volume_grid::GVolumeGrid &
volume_grid,
1677 BlobWriter &blob_writer,
1678 BlobWriteSharing & ,
1679 DictionaryValue &r_io_item)
1681 r_io_item.append_str(
"type",
"GRID");
1682 auto io_vdb = blob_writer
1683 .write_as_stream(
".vdb",
1684 [&](std::ostream &stream) {
1685 openvdb::GridCPtrVec vdb_grids;
1686 bke::VolumeTreeAccessToken tree_token;
1687 vdb_grids.push_back(
volume_grid->grid_ptr(tree_token));
1688 openvdb::io::Stream vdb_stream(stream);
1689 vdb_stream.write(vdb_grids);
1692 r_io_item.append(
"vdb", std::move(io_vdb));
1707 std::optional<eCustomDataType> data_type;
1709 r_io_item.
append_str(
"item_type",
"SOCKET_VALUE_VARIANT");
1712 r_io_item.
append_str(
"item_type",
"GEOMETRY");
1717 else if (type.
is<std::string>()) {
1726 if (
const auto *single_data = std::get_if<nodes::GList::SingleData>(&
list.data())) {
1729 GPointer{type, single_data->value}, blob_writer, blob_sharing, io_single_value);
1731 else if (
const auto *array_data = std::get_if<nodes::GList::ArrayData>(&
list.data())) {
1732 const GSpan array_span{type, array_data->data,
list.size()};
1736 blob_writer, blob_sharing, array_span, array_data->sharing_info.get()));
1754 io_value, blob_reader, blob_sharing);
1755 if (!value || !value->is_single()) {
1756 return std::nullopt;
1758 return value->extract<
T>();
1764 const int num_items,
1772 return std::nullopt;
1779 if (!io_values || io_values->
elements().size() != num_items) {
1780 return std::nullopt;
1782 GArray<> values(cpp_type, num_items);
1787 return std::nullopt;
1791 return std::nullopt;
1793 values_span[i] = std::move(*value);
1804 const GPointer single_value = value_variant.
get();
1816 serialize_volume_grid(
volume_grid, blob_writer, blob_sharing, r_io_item);
1820 if (value_variant.
is_list()) {
1832 if (item.
name.has_value()) {
1842 const std::optional<StringRefNull> state_item_type = io_item.
lookup_str(
"type");
1843 if (!state_item_type) {
1846 if (*state_item_type ==
StringRef(
"GEOMETRY")) {
1854 if (*state_item_type ==
StringRef(
"ATTRIBUTE")) {
1856 if (!io_attribute) {
1859 std::optional<StringRefNull> name = io_attribute->
lookup_str(
"name");
1863 const CPPType *field_cpp_type =
nullptr;
1864 if (
const std::optional<StringRefNull> type = io_attribute->
lookup_str(
"data_type")) {
1869 if (field_cpp_type) {
1878 if (*state_item_type ==
StringRef(
"GRID")) {
1888 openvdb::GridPtrVecPtr vdb_grids;
1890 [&](std::istream &stream) {
1892 openvdb::io::Stream vdb_stream{stream};
1893 vdb_grids = vdb_stream.getGrids();
1903 if (vdb_grids->size() != 1) {
1906 std::shared_ptr<openvdb::GridBase> vdb_grid = std::move((*vdb_grids)[0]);
1907 GVolumeGrid grid{std::move(vdb_grid)};
1911 if (*state_item_type ==
StringRef(
"STRING")) {
1912 const std::shared_ptr<io::serialize::Value> *io_data = io_item.
lookup(
"data");
1917 const io::serialize::StringValue &io_string = *io_data->get()->as_string_value();
1920 if (
const io::serialize::DictionaryValue *io_string = io_data->get()->as_dictionary_value()) {
1921 const std::optional<int64_t>
size = io_string->lookup_int(
"size");
1933 if (*state_item_type ==
StringRef(
"BUNDLE")) {
1935 nodes::Bundle &bundle = bundle_ptr.ensure_mutable_inplace();
1936 const ArrayValue *io_bundle_items = io_item.lookup_array(
"items");
1937 if (!io_bundle_items) {
1945 if (*state_item_type ==
StringRef(
"LIST")) {
1946 const std::optional<StringRefNull> io_list_item_type = io_item.lookup_str(
"item_type");
1947 if (!io_list_item_type) {
1950 const std::optional<int> num_items = io_item.lookup_int(
"num_items");
1954 if (io_list_item_type ==
"SOCKET_VALUE_VARIANT") {
1956 const ArrayValue *io_values = io_item.lookup_array(
"data");
1960 if (io_values->elements().size() != *num_items) {
1969 *io_value, blob_reader, blob_sharing);
1973 values[i] = std::move(*value);
1977 if (io_list_item_type ==
"GEOMETRY") {
1978 return deserialize_value_list<GeometrySet>(io_item, *num_items, blob_reader, blob_sharing);
1980 if (io_list_item_type ==
"BUNDLE") {
1981 return deserialize_value_list<nodes::BundlePtr>(
1982 io_item, *num_items, blob_reader, blob_sharing);
1984 if (io_list_item_type ==
"STRING") {
1985 return deserialize_value_list<std::string>(io_item, *num_items, blob_reader, blob_sharing);
1988 *io_list_item_type))
1992 if (
const std::shared_ptr<io::serialize::Value> *io_value = io_item.lookup(
"value")) {
2001 if (
const io::serialize::DictionaryValue *io_data = io_item.lookup_dict(
"data")) {
2002 GArray<> buffer(*cpp_type, *num_items);
2004 blob_reader, *io_data, GMutableSpan{cpp_type, buffer.data(), *num_items}))
2012 const std::shared_ptr<io::serialize::Value> *io_data = io_item.lookup(
"data");
2025 cpp_type.copy_construct(buffer, value.allocate_single(cpp_type));
2036 std::ostream &r_stream)
2042 for (
const auto &item : bake_values.
values_by_id().items()) {
2057 std::unique_ptr<io::serialize::Value> io_root_value;
2062 return std::nullopt;
2064 if (!io_root_value) {
2065 return std::nullopt;
2069 return std::nullopt;
2071 const std::optional<int> version = io_root->
lookup_int(
"version");
2073 return std::nullopt;
2077 return std::nullopt;
2080 for (
const auto &io_item_value : io_items->
elements()) {
2083 return std::nullopt;
2087 id = std::stoi(io_item_value.first);
2090 return std::nullopt;
2093 return std::nullopt;
2096 *io_item, blob_reader, blob_sharing);
2098 return std::nullopt;
Low-level operations for curves.
CustomData interface, see also DNA_customdata_types.h.
Low-level operations for grease pencil.
General operations for point clouds.
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name)
#define BLI_SCOPED_DEFER(function_to_defer)
#define BLI_path_join(...)
#define STRNCPY_UTF8(dst, src)
Object is a sort of wrapper for general info.
#define PRF_scope(category)
#define BLI_assert_unreachable()
virtual bool serialize(void *o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const
Data buffer MUST be 16 byte aligned.
MutableSpan< T > as_mutable_span()
static const CPPType & get()
void copy_assign_n(const void *src, void *dst, int64_t n) const
GMutableSpan as_mutable_span()
int64_t size_in_bytes() const
MutableSpan< T > typed() const
const CPPType * type() const
void add_weak_user() const
void remove_user_and_delete_if_last() const
T & ensure_mutable_inplace()
constexpr int64_t size() const
constexpr bool is_empty() const
constexpr IndexRange()=default
static constexpr IndexRange from_begin_size(const int64_t begin, const int64_t size)
constexpr int64_t start() const
constexpr bool contains(int64_t value) const
void add_new(const Key &key, const Value &value)
bool contains(const Key &key) const
constexpr int64_t size() const
constexpr IndexRange index_range() const
bool contains_as(const ForwardKey &key) const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T * data() const
constexpr IndexRange index_range() const
constexpr const char * c_str() const
void append(const T &value)
const T & last(const int64_t n=0) const
Span< T > as_span() const
void append_as(ForwardValue &&...value)
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
bool contains(StringRef name) const
int domain_size(const AttrDomain domain) const
GAttributeReader get() const
Span< InstanceReference > references() const
bke::AttributeAccessor attributes() const
int instances_num() const
bool add(const StringRef name, const AttrDomain domain, const AttrType data_type, const AttributeInit &initializer)
bool assign_data(const StringRef name, const AttributeInit &initializer)
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
bool is_context_dependent_field() const
bool is_volume_grid() const
static SocketValueVariant from(T &&value)
const Map< int, Item > & values_by_id() const
std::optional< ImplicitSharingInfoAndData > read_shared(const io::serialize::DictionaryValue &io_data, FunctionRef< std::optional< ImplicitSharingInfoAndData >()> read_fn) const
virtual bool read_as_stream(const BlobSlice &slice, FunctionRef< bool(std::istream &)> fn) const
virtual bool read(const BlobSlice &slice, void *r_data) const =0
std::shared_ptr< io::serialize::DictionaryValue > write_implicitly_shared(const ImplicitSharingInfo *sharing_info, FunctionRef< std::shared_ptr< io::serialize::DictionaryValue >()> write_fn)
std::shared_ptr< io::serialize::DictionaryValue > write_deduplicated(BlobWriter &writer, const void *data, int64_t size_in_bytes)
virtual BlobSlice write(const void *data, int64_t size)=0
virtual BlobSlice write_as_stream(StringRef file_extension, FunctionRef< void(std::ostream &)> fn)
int64_t total_written_size_
bool read(const BlobSlice &slice, void *r_data) const override
DiskBlobReader(std::string blobs_dir)
DiskBlobWriter(std::string blob_dir, std::string base_name)
BlobSlice write_as_stream(StringRef file_extension, FunctionRef< void(std::ostream &)> fn) override
BlobSlice write(const void *data, int64_t size) override
void add(StringRef name, Span< std::byte > blob)
bool read(const BlobSlice &slice, void *r_data) const override
MemoryBlobWriter(std::string base_name)
BlobSlice write(const void *data, int64_t size) override
BlobSlice write_as_stream(StringRef file_extension, FunctionRef< void(std::ostream &)> fn) override
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
constexpr bool startswith(StringRef prefix) const
constexpr bool is_empty() const
static GField from_input(Args &&...args)
const InputT * get_input_if() const
const CPPType & cpp_type() const
Span< std::shared_ptr< Value > > elements() const
std::shared_ptr< DictionaryValue > append_dict()
const std::shared_ptr< Value > * lookup(StringRef key) const
void append(std::string key, std::shared_ptr< Value > value)
std::optional< StringRefNull > lookup_str(StringRef key) const
void append_str(std::string key, std::string value)
std::shared_ptr< DictionaryValue > append_dict(std::string key)
std::optional< int64_t > lookup_int(StringRef key) const
Span< Item > elements() const
void append_int(std::string key, int64_t value)
std::shared_ptr< ArrayValue > append_array(std::string key)
const DictionaryValue * lookup_dict(StringRef key) const
const ArrayValue * lookup_array(StringRef key) const
std::optional< bool > lookup_bool(StringRef key) const
const BooleanValue * as_boolean_value() const
const ArrayValue * as_array_value() const
const IntValue * as_int_value() const
const DoubleValue * as_double_value() const
const DictionaryValue * as_dictionary_value() const
static std::optional< BundleKey > from_str(StringRef key)
bool add(BundleKey key, const BundleItemValue &value)
static BundlePtr create()
BundleItemMap::ItemIterator items() const
static SingleData ForValue(const GPointer &value)
static GListPtr from_garray(GArray<> array)
static GListPtr from_container(ContainerT &&container)
static GListPtr create(const CPPType &type, DataVariant data, const int64_t size)
static bool deserialize_typed_array(const io::serialize::Value &io_value, FunctionRef< std::optional< T >(const io::serialize::Value &io_element)> fn, MutableSpan< T > r_values)
static StringRefNull get_domain_io_name(const AttrDomain domain)
static constexpr int bake_file_version
static bool read_blob_shared_simple_span(const DictionaryValue &io_data, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing, const int size, T **r_data, const ImplicitSharingInfo **r_sharing_info)
static std::optional< AttrDomain > get_domain_from_io_name(const StringRefNull io_name)
static std::optional< eCustomDataType > get_data_type_from_io_name(const StringRefNull io_name)
static void serialize_field(const fn::GField &field, BlobWriter &, BlobWriteSharing &, DictionaryValue &r_io_item)
static bool deserialize_int_array(const io::serialize::Value &io_value, MutableSpan< T > r_values)
static bool read_blob_simple_gspan(const BlobReader &blob_reader, const DictionaryValue &io_data, GMutableSpan r_data)
static std::shared_ptr< io::serialize::ArrayValue > serialize_int_array(const Span< int > values)
static bool read_blob_raw_bytes(const BlobReader &blob_reader, const DictionaryValue &io_data, const int64_t bytes_num, void *r_data)
static StringRefNull get_data_type_io_name(const eCustomDataType data_type)
static std::optional< T > deserialize_list_item(const DictionaryValue &io_value, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static bool load_materials(const io::serialize::ArrayValue &io_materials, std::unique_ptr< BakeMaterialsList > &materials)
static void serialize_single_value(const GPointer value, BlobWriter &blob_writer, BlobWriteSharing &blob_sharing, DictionaryValue &r_io_item)
static std::optional< SocketValueVariant > deserialize_value_list(const DictionaryValue &io_item, const int num_items, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static StringRefNull get_storage_type_io_name(const AttrStorageType storage_type)
static std::optional< CurvesGeometry > try_load_curves_geometry(const DictionaryValue &io_curves, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static std::optional< float > deserialize_float(const io::serialize::Value &io_value)
static std::optional< T > deserialize_int(const io::serialize::Value &io_value)
static std::shared_ptr< io::serialize::Value > serialize_primitive_value(const eCustomDataType data_type, const void *value_ptr)
static bool load_attributes(const io::serialize::ArrayValue &io_attributes, MutableAttributeAccessor &attributes, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static void serialize_curves_geometry(DictionaryValue &io_curves, const CurvesGeometry &curves, BlobWriter &blob_writer, BlobWriteSharing &blob_sharing)
static std::shared_ptr< DictionaryValue > write_blob_raw_bytes(BlobWriter &blob_writer, BlobWriteSharing &blob_sharing, const void *data, const int64_t size_in_bytes)
static std::shared_ptr< DictionaryValue > serialize_geometry_set(const GeometrySet &geometry, BlobWriter &blob_writer, BlobWriteSharing &blob_sharing)
static Curves * try_load_curves(const DictionaryValue &io_geometry, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static std::optional< SocketValueVariant > deserialize_bake_item(const DictionaryValue &io_item, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static std::shared_ptr< DictionaryValue > write_blob_shared_simple_gspan(BlobWriter &blob_writer, BlobWriteSharing &blob_sharing, const GSpan data, const ImplicitSharingInfo *sharing_info)
static std::optional< AttrStorageType > get_storage_type_from_io_name(const StringRefNull io_name)
void serialize_bake(const BakeValues &bake_values, BlobWriter &blob_writer, BlobWriteSharing &blob_sharing, std::ostream &r_stream)
static GeometrySet load_geometry(const DictionaryValue &io_geometry, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static Mesh * try_load_mesh(const DictionaryValue &io_geometry, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
std::optional< BakeValues > deserialize_bake(std::istream &stream, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static PointCloud * try_load_pointcloud(const DictionaryValue &io_geometry, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static bool deserialize_primitive_value(const io::serialize::Value &io_value, const eCustomDataType type, void *r_value)
std::shared_ptr< DictionaryValue > DictionaryValuePtr
static std::shared_ptr< DictionaryValue > write_blob_simple_gspan(BlobWriter &blob_writer, BlobWriteSharing &blob_sharing, const GSpan data)
static GreasePencil * try_load_grease_pencil(const DictionaryValue &io_geometry, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static const void * read_blob_shared_simple_gspan(const DictionaryValue &io_data, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing, const CPPType &cpp_type, const int size, const ImplicitSharingInfo **r_sharing_info)
static std::unique_ptr< Instances > try_load_instances(const DictionaryValue &io_geometry, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static bool deserialize_float_array(const io::serialize::Value &io_value, MutableSpan< float > r_values)
static void serialize_texture_space(const Mesh &mesh, std::shared_ptr< DictionaryValue > io_mesh)
static void serialize_list(const nodes::GListPtr &list_ptr, BlobWriter &blob_writer, BlobWriteSharing &blob_sharing, DictionaryValue &r_io_item)
static void serialize_bundle_items(const nodes::Bundle &bundle, ArrayValue &r_io_items, BlobWriter &blob_writer, BlobWriteSharing &blob_sharing)
static std::string make_independent_file_name(const StringRef base_name, const int file_index, const StringRef extension)
static nodes::BundlePtr try_load_geometry_bundle(const DictionaryValue &io_geometry, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
static void load_texspace(const DictionaryValue *io_mesh, Mesh *mesh)
static std::shared_ptr< io::serialize::ArrayValue > serialize_float_array(const Span< float > values)
static bool deserialize_bundle_items(const io::serialize::ArrayValue &io_bundle_items, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing, nodes::Bundle &r_bundle)
static std::shared_ptr< io::serialize::ArrayValue > serialize_attributes(const AttributeAccessor &attributes, BlobWriter &blob_writer, BlobWriteSharing &blob_sharing, const Set< std::string > &attributes_to_ignore)
static void serialize_bake_item(const BakeValues::Item &item, BlobWriter &blob_writer, BlobWriteSharing &blob_sharing, DictionaryValue &r_io_item)
static void serialize_socket_value_variant(const SocketValueVariant &value_variant, BlobWriter &blob_writer, BlobWriteSharing &blob_sharing, DictionaryValue &r_io_item)
static std::shared_ptr< io::serialize::ArrayValue > serialize_materials(const std::unique_ptr< BakeMaterialsList > &materials)
std::optional< eCustomDataType > attr_type_to_custom_data_type(AttrType attr_type)
bool attribute_name_is_anonymous(const StringRef name)
std::optional< eCustomDataType > cpp_type_to_custom_data_type(const CPPType &type)
const CPPType * custom_data_type_to_cpp_type(eCustomDataType type)
PointCloud * pointcloud_new_no_attributes(PointCloudType type, int totpoint)
std::optional< AttrType > custom_data_type_to_attr_type(eCustomDataType data_type)
Mesh * mesh_new_no_attributes(int verts_num, int edges_num, int faces_num, int corners_num)
bNodeSocketType * node_socket_type_find(StringRef idname)
Curves * curves_new_nomain(int points_num, int curves_num)
int size(const AssetLibraryReference *library_reference)
PrimitiveValue< int64_t, eValueType::Int > IntValue
PrimitiveValue< bool, eValueType::Boolean > BooleanValue
PrimitiveValue< double, eValueType::Double > DoubleValue
QuaternionBase< float > Quaternion
ImplicitSharingPtr< Bundle > BundlePtr
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
unsigned __int64 uint64_t
VecBase< int32_t, 4 > int4
int BKE_volume_num_grids(const Volume *volume)
GreasePencilLayerBlendMode
const bke::VolumeGridData * BKE_volume_grid_get(const Volume *volume, int grid_index)
char * BLI_strdupn(const char *str, size_t len) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
MatBase< float, 4, 4 > float4x4
VecBase< float, 4 > float4
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
BMesh const char void * data
const EnumPropertyItem rna_enum_attr_storage_type_items[]
const EnumPropertyItem rna_enum_attribute_type_items[]
void BKE_volume_grid_add(Volume *volume, const bke::VolumeGridData &grid)
bool RNA_enum_id_from_value(const EnumPropertyItem *item, int value, const char **r_identifier)
void BKE_id_free(Main *bmain, void *idv)
void * BKE_id_new_nomain(short type, const char *name)
bool RNA_enum_value_from_identifier(const EnumPropertyItem *item, const char *identifier, int *r_value)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
VecBase< int16_t, 2 > short2
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
VecBase< float, 3 > float3
ATTR_WARN_UNUSED_RESULT const void * element
bool BLI_file_ensure_parent_dir_exists(const char *filepath) ATTR_NONNULL(1)
GreasePencil * BKE_grease_pencil_new_nomain()
const EnumPropertyItem rna_enum_attribute_domain_items[]
ColorSceneLinearByteEncoded4b< eAlpha::Premultiplied > ColorGeometry4b
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
static constexpr int col_len
static constexpr int row_len
const T * base_ptr() const
bke::PointCloudRuntime * runtime
bke::VolumeRuntime * runtime
AttributeInitShared(const void *data, const ImplicitSharingInfo &sharing_info)
std::unique_ptr< bake::BakeMaterialsList > bake_materials
std::unique_ptr< bake::BakeMaterialsList > bake_materials
BakeDataBlockID(ID_Type type, std::string id_name, std::string lib_name)
std::optional< std::string > name
std::shared_ptr< io::serialize::DictionaryValue > serialize() const
static std::optional< BlobSlice > deserialize(const io::serialize::DictionaryValue &io_slice)
std::unique_ptr< std::ostringstream > stream