25# include <openvdb/Grid.h>
26# include <openvdb/tools/Prune.h>
27# include <openvdb/tree/LeafManager.h>
34VolumeGridData::VolumeGridData()
36 tree_access_token_ = std::make_shared<AccessToken>(*
this);
40 template<
typename Gr
idT> openvdb::GridBase::Ptr
operator()()
const
42 return GridT::create();
46static openvdb::GridBase::Ptr create_grid_for_type(
const VolumeGridType grid_type)
48 return BKE_volume_grid_type_operation(grid_type, CreateGridOp{});
52 : VolumeGridData(create_grid_for_type(grid_type))
56VolumeGridData::VolumeGridData(std::shared_ptr<openvdb::GridBase> grid)
57 : grid_(std::move(grid)), tree_loaded_(
true), transform_loaded_(
true), meta_data_loaded_(
true)
63 tree_sharing_info_ = OpenvdbTreeSharingInfo::make(grid_->baseTreePtr());
64 tree_access_token_ = std::make_shared<AccessToken>(*
this);
67VolumeGridData::VolumeGridData(std::function<LazyLoadedGrid()> lazy_load_grid,
68 std::shared_ptr<openvdb::GridBase> meta_data_and_transform_grid)
69 : grid_(std::move(meta_data_and_transform_grid)), lazy_load_grid_(std::move(lazy_load_grid))
72 transform_loaded_ =
true;
73 meta_data_loaded_ =
true;
75 tree_access_token_ = std::make_shared<AccessToken>(*
this);
78VolumeGridData::~VolumeGridData()
81 BLI_assert(tree_access_token_.use_count() == 1);
84void VolumeGridData::delete_self()
89const openvdb::GridBase &VolumeGridData::grid(VolumeTreeAccessToken &r_token)
const
91 return *this->grid_ptr(r_token);
94openvdb::GridBase &VolumeGridData::grid_for_write(VolumeTreeAccessToken &r_token)
96 return *this->grid_ptr_for_write(r_token);
99std::shared_ptr<const openvdb::GridBase> VolumeGridData::grid_ptr(
100 VolumeTreeAccessToken &r_token)
const
102 std::lock_guard
lock{mutex_};
103 this->ensure_grid_loaded();
104 r_token.token_ = tree_access_token_;
108std::shared_ptr<openvdb::GridBase> VolumeGridData::grid_ptr_for_write(
109 VolumeTreeAccessToken &r_token)
112 std::lock_guard
lock{mutex_};
113 this->ensure_grid_loaded();
114 r_token.token_ = tree_access_token_;
115 if (tree_sharing_info_->is_mutable()) {
116 tree_sharing_info_->tag_ensured_mutable();
119 auto tree_copy = grid_->baseTree().copy();
120 grid_->setTree(tree_copy);
121 tree_sharing_info_ = OpenvdbTreeSharingInfo::make(std::move(tree_copy));
124 lazy_load_grid_ = {};
128const openvdb::math::Transform &VolumeGridData::transform()
const
130 std::lock_guard
lock{mutex_};
131 if (!transform_loaded_) {
132 this->ensure_grid_loaded();
134 return grid_->transform();
137openvdb::math::Transform &VolumeGridData::transform_for_write()
140 std::lock_guard
lock{mutex_};
141 if (!transform_loaded_) {
142 this->ensure_grid_loaded();
144 return grid_->transform();
147std::string VolumeGridData::name()
const
149 std::lock_guard
lock{mutex_};
150 if (!meta_data_loaded_) {
151 this->ensure_grid_loaded();
153 return grid_->getName();
156void VolumeGridData::set_name(
const StringRef name)
159 std::lock_guard
lock{mutex_};
160 if (!meta_data_loaded_) {
161 this->ensure_grid_loaded();
163 grid_->setName(name);
168 std::lock_guard
lock{mutex_};
169 if (!meta_data_loaded_) {
170 this->ensure_grid_loaded();
175std::optional<VolumeGridType> VolumeGridData::grid_type_without_load()
const
177 std::lock_guard
lock{mutex_};
178 if (!meta_data_loaded_) {
184openvdb::GridClass VolumeGridData::grid_class()
const
186 std::lock_guard
lock{mutex_};
187 if (!meta_data_loaded_) {
188 this->ensure_grid_loaded();
190 return grid_->getGridClass();
193bool VolumeGridData::is_reloadable()
const
195 return bool(lazy_load_grid_);
198void VolumeGridData::tag_tree_modified()
const
200 active_voxels_mutex_.tag_dirty();
201 active_leaf_voxels_mutex_.tag_dirty();
202 active_tiles_mutex_.tag_dirty();
203 size_in_bytes_mutex_.tag_dirty();
204 active_bounds_mutex_.tag_dirty();
207bool VolumeGridData::is_loaded()
const
209 std::lock_guard
lock{mutex_};
210 return tree_loaded_ && transform_loaded_ && meta_data_loaded_;
213const CPPType *VolumeGridData::cpp_type()
const
216 const CPPType *cpp_type =
nullptr;
217 BKE_volume_grid_type_to_blender_value_type(grid_type,
218 [&]<
typename T>() { cpp_type = &CPPType::get<T>(); });
222void VolumeGridData::count_memory(MemoryCounter &memory)
const
224 std::lock_guard
lock{mutex_};
228 memory.add_shared(tree_sharing_info_.get(), [&](MemoryCounter &shared_memory) {
229 shared_memory.add(this->size_in_bytes());
233int64_t VolumeGridData::active_voxels()
const
235 active_voxels_mutex_.ensure([&]() {
236 VolumeTreeAccessToken token;
237 const openvdb::GridBase &grid = this->grid(token);
238 const openvdb::TreeBase &tree = grid.baseTree();
239 active_voxels_ = tree.activeVoxelCount();
241 return active_voxels_;
244int64_t VolumeGridData::active_leaf_voxels()
const
246 active_leaf_voxels_mutex_.ensure([&]() {
247 VolumeTreeAccessToken token;
248 const openvdb::GridBase &grid = this->grid(token);
249 const openvdb::TreeBase &tree = grid.baseTree();
250 active_leaf_voxels_ = tree.activeLeafVoxelCount();
252 return active_leaf_voxels_;
255int64_t VolumeGridData::active_tiles()
const
257 active_tiles_mutex_.ensure([&]() {
258 VolumeTreeAccessToken token;
259 const openvdb::GridBase &grid = this->grid(token);
260 const openvdb::TreeBase &tree = grid.baseTree();
261 active_tiles_ = tree.activeTileCount();
263 return active_tiles_;
266int64_t VolumeGridData::size_in_bytes()
const
268 size_in_bytes_mutex_.ensure([&]() {
269 VolumeTreeAccessToken token;
270 const openvdb::GridBase &grid = this->grid(token);
271 const openvdb::TreeBase &tree = grid.baseTree();
272 size_in_bytes_ = tree.memUsage();
274 return size_in_bytes_;
277const openvdb::CoordBBox &VolumeGridData::active_bounds()
const
279 active_bounds_mutex_.ensure([&]() {
280 VolumeTreeAccessToken token;
281 const openvdb::GridBase &grid = this->grid(token);
282 const openvdb::TreeBase &tree = grid.baseTree();
283 tree.evalActiveVoxelBoundingBox(active_bounds_);
285 return active_bounds_;
288std::string VolumeGridData::error_message()
const
290 std::lock_guard
lock{mutex_};
291 return error_message_;
294void VolumeGridData::unload_tree_if_possible()
const
296 std::lock_guard
lock{mutex_};
303 if (!this->is_reloadable()) {
306 if (tree_access_token_.use_count() != 1) {
311 tree_loaded_ =
false;
312 tree_sharing_info_.reset();
315GVolumeGrid VolumeGridData::copy()
const
317 std::lock_guard
lock{mutex_};
318 this->ensure_grid_loaded();
323 new_copy->grid_ = grid_->copyGrid();
324 new_copy->tree_sharing_info_ = tree_sharing_info_;
325 new_copy->tree_loaded_ = tree_loaded_;
326 new_copy->transform_loaded_ = transform_loaded_;
327 new_copy->meta_data_loaded_ = meta_data_loaded_;
328 return GVolumeGrid(new_copy);
331void VolumeGridData::ensure_grid_loaded()
const
336 if (tree_loaded_ && transform_loaded_ && meta_data_loaded_) {
340 LazyLoadedGrid loaded_grid;
342 threading::isolate_task([&]() {
343 error_message_.clear();
345 loaded_grid = lazy_load_grid_();
347 catch (
const openvdb::IoError &e) {
348 error_message_ =
e.what();
351 error_message_ =
"Unknown error reading VDB file";
354 if (!loaded_grid.grid) {
357 const openvdb::Name &grid_type = grid_->type();
358 if (openvdb::GridBase::isRegistered(grid_type)) {
360 loaded_grid.grid = openvdb::GridBase::createGrid(grid_type);
364 if (!loaded_grid.grid) {
366 loaded_grid.grid = openvdb::FloatGrid::create();
369 BLI_assert(loaded_grid.grid.use_count() == 1);
371 if (!loaded_grid.tree_sharing_info) {
373 loaded_grid.tree_sharing_info = OpenvdbTreeSharingInfo::make(loaded_grid.grid->baseTreePtr());
380 grid_->setTree(loaded_grid.grid->baseTreePtr());
381 if (!transform_loaded_) {
382 grid_->setTransform(loaded_grid.grid->transformPtr());
386 grid_ = std::move(loaded_grid.grid);
391 tree_sharing_info_ = std::move(loaded_grid.tree_sharing_info);
394 transform_loaded_ =
true;
395 meta_data_loaded_ =
true;
398GVolumeGrid::GVolumeGrid(std::shared_ptr<openvdb::GridBase> grid)
400 data_ = ImplicitSharingPtr(MEM_new<VolumeGridData>(__func__, std::move(grid)));
403GVolumeGrid::GVolumeGrid(
const VolumeGridType grid_type)
404 : GVolumeGrid(create_grid_for_type(grid_type))
408VolumeGridData &GVolumeGrid::get_for_write()
411 if (data_->is_mutable()) {
412 data_->tag_ensured_mutable();
415 *
this = data_->copy();
417 return const_cast<VolumeGridData &
>(*data_);
422 if (tree.isType<openvdb::FloatTree>()) {
425 if (tree.isType<openvdb::Vec3fTree>()) {
428 if (tree.isType<openvdb::BoolTree>()) {
431 if (tree.isType<openvdb::DoubleTree>()) {
434 if (tree.isType<openvdb::Int32Tree>()) {
437 if (tree.isType<openvdb::Int64Tree>()) {
440 if (tree.isType<openvdb::Vec3ITree>()) {
443 if (tree.isType<openvdb::Vec3dTree>()) {
446 if (tree.isType<openvdb::MaskTree>()) {
449 if (tree.isType<openvdb::points::PointDataTree>()) {
460ImplicitSharingPtr<> OpenvdbTreeSharingInfo::make(std::shared_ptr<openvdb::tree::TreeBase> tree)
462 return ImplicitSharingPtr<>{MEM_new<OpenvdbTreeSharingInfo>(__func__, std::move(tree))};
465OpenvdbTreeSharingInfo::OpenvdbTreeSharingInfo(std::shared_ptr<openvdb::tree::TreeBase> tree)
466 : tree_(std::move(tree))
470void OpenvdbTreeSharingInfo::delete_self_with_data()
475void OpenvdbTreeSharingInfo::delete_data_only()
480VolumeTreeAccessToken::~VolumeTreeAccessToken()
482 const VolumeGridData *grid = token_ ? &token_->grid :
nullptr;
487 grid->unload_tree_if_possible();
506 return grid.grid_type();
537 return BKE_volume_transform_to_blender(grid.transform());
547 grid.transform_for_write() = BKE_volume_transform_to_openvdb(matrix);
556 VolumeTreeAccessToken tree_token;
557 grid.grid_for_write(tree_token).clear();
558 grid.tag_tree_modified();
567 return grid.is_loaded();
577 grid.count_memory(memory);
583void load(
const VolumeGridData &grid)
586 VolumeTreeAccessToken tree_token;
588 grid.grid(tree_token);
597 return grid.error_message();
610template<
typename LeafNodeT>
611static void parallel_grid_topology_tasks_leaf_node(
const LeafNodeT &
node,
612 const ProcessLeafFn process_leaf_fn,
615 using NodeMaskT =
typename LeafNodeT::NodeMaskType;
617 const int on_count =
node.onVoxelCount();
621 const int on_count_threshold = 64;
622 if (on_count <= on_count_threshold) {
625 for (
auto value_iter =
node.cbeginValueOn(); value_iter.test(); ++value_iter) {
626 const openvdb::Coord coord = value_iter.getCoord();
634 const NodeMaskT &value_mask =
node.getValueMask();
635 const openvdb::CoordBBox bbox =
node.getNodeBoundingBox();
636 process_leaf_fn(value_mask, bbox, [&](MutableSpan<openvdb::Coord> r_voxels) {
637 for (
auto value_iter =
node.cbeginValueOn(); value_iter.test(); ++value_iter) {
638 r_voxels[value_iter.pos()] = value_iter.getCoord();
646template<
typename InternalNodeT>
647static void parallel_grid_topology_tasks_internal_node(
const InternalNodeT &
node,
648 const ProcessLeafFn process_leaf_fn,
649 const ProcessVoxelsFn process_voxels_fn,
650 const ProcessTilesFn process_tiles_fn)
652 using ChildNodeT =
typename InternalNodeT::ChildNodeType;
653 using LeafNodeT =
typename InternalNodeT::LeafNodeType;
654 using NodeMaskT =
typename InternalNodeT::NodeMaskType;
655 using UnionT =
typename InternalNodeT::UnionType;
658 const NodeMaskT &child_mask =
node.getChildMask();
659 const UnionT *table =
node.getTable();
660 Vector<int, 512> child_indices;
661 for (
auto child_mask_iter = child_mask.beginOn(); child_mask_iter.test(); ++child_mask_iter) {
662 child_indices.append(child_mask_iter.pos());
665 threading::parallel_for(child_indices.index_range(), 8, [&](
const IndexRange range) {
669 Vector<openvdb::Coord, 1024> gathered_voxels;
670 for (const int child_index : child_indices.as_span().slice(range)) {
671 const ChildNodeT &child = *table[child_index].getChild();
672 if constexpr (std::is_same_v<ChildNodeT, LeafNodeT>) {
673 parallel_grid_topology_tasks_leaf_node(child, process_leaf_fn, gathered_voxels);
675 if (gathered_voxels.size() >= 512) {
676 process_voxels_fn(gathered_voxels);
677 gathered_voxels.clear();
682 parallel_grid_topology_tasks_internal_node(
683 child, process_leaf_fn, process_voxels_fn, process_tiles_fn);
687 if (!gathered_voxels.is_empty()) {
688 process_voxels_fn(gathered_voxels);
689 gathered_voxels.clear();
696 const NodeMaskT &value_mask =
node.getValueMask();
697 Vector<openvdb::CoordBBox> tile_bboxes;
698 for (
auto value_mask_iter = value_mask.beginOn(); value_mask_iter.test(); ++value_mask_iter) {
699 const openvdb::Index32
index = value_mask_iter.pos();
700 const openvdb::Coord tile_origin =
node.offsetToGlobalCoord(
index);
701 const openvdb::CoordBBox tile_bbox = openvdb::CoordBBox::createCube(tile_origin,
703 tile_bboxes.append(tile_bbox);
705 if (!tile_bboxes.is_empty()) {
706 process_tiles_fn(tile_bboxes);
711void parallel_grid_topology_tasks(
const openvdb::MaskTree &mask_tree,
712 const ProcessLeafFn process_leaf_fn,
713 const ProcessVoxelsFn process_voxels_fn,
714 const ProcessTilesFn process_tiles_fn)
717 for (
auto root_child_iter = mask_tree.cbeginRootChildren(); root_child_iter.test();
720 const auto &internal_node = *root_child_iter;
721 parallel_grid_topology_tasks_internal_node(
722 internal_node, process_leaf_fn, process_voxels_fn, process_tiles_fn);
726openvdb::GridBase::Ptr create_grid_with_topology(
const openvdb::MaskTree &topology,
727 const openvdb::math::Transform &
transform,
728 const VolumeGridType grid_type)
730 openvdb::GridBase::Ptr grid;
731 BKE_volume_grid_type_to_static_type(
732 grid_type, [&]<std::derived_from<openvdb::GridBase> GridT>() {
733 using TreeT =
typename GridT::TreeType;
734 using ValueType =
typename TreeT::ValueType;
735 const ValueType background{};
736 auto tree = std::make_shared<TreeT>(topology, background, openvdb::TopologyCopy());
737 grid = openvdb::createGrid(std::move(tree));
743void set_grid_values(openvdb::GridBase &grid_base,
748 to_typed_grid(grid_base, [&](
auto &grid) {
749 using GridT = std::decay_t<
decltype(grid)>;
750 using ValueType =
typename GridT::ValueType;
751 const ValueType *
data =
static_cast<const ValueType *
>(values.data());
753 auto accessor = grid.getUnsafeAccessor();
755 accessor.setValue(voxels[i], data[i]);
760void set_tile_values(openvdb::GridBase &grid_base,
765 to_typed_grid(grid_base, [&](
auto &grid) {
766 using GridT =
typename std::decay_t<
decltype(grid)>;
767 using TreeT =
typename GridT::TreeType;
768 using ValueType =
typename GridT::ValueType;
769 auto &tree = grid.tree();
771 const ValueType *computed_values =
static_cast<const ValueType *
>(values.data());
773 const auto set_tile_value = [&](
auto &
node,
const openvdb::Coord &coord_in_tile,
auto value) {
774 const openvdb::Index n =
node.coordToOffset(coord_in_tile);
780 using UnionType =
typename std::decay_t<
decltype(
node)>::UnionType;
781 auto *table =
const_cast<UnionType *
>(
node.getTable());
782 table[n].setValue(value);
785 for (
const int i :
tiles.index_range()) {
786 const openvdb::CoordBBox
tile =
tiles[i];
787 const openvdb::Coord coord_in_tile =
tile.min();
788 const auto &computed_value = computed_values[i];
789 using InternalNode1 =
typename TreeT::RootNodeType::ChildNodeType;
790 using InternalNode2 =
typename InternalNode1::ChildNodeType;
792 if (
auto *
node = tree.template probeNode<InternalNode2>(coord_in_tile)) {
793 set_tile_value(*
node, coord_in_tile, computed_value);
795 else if (
auto *
node = tree.template probeNode<InternalNode1>(coord_in_tile)) {
796 set_tile_value(*
node, coord_in_tile, computed_value);
805void set_leaf_values_off(openvdb::GridBase &grid_base,
806 const openvdb::Coord &probe_coord,
809 to_typed_grid(grid_base, [&](
auto &grid) {
810 using GridType = std::decay_t<
decltype(grid)>;
811 using TreeType =
typename GridType::TreeType;
812 using LeafNodeType =
typename TreeType::LeafNodeType;
813 using NodeMaskType =
typename LeafNodeType::NodeMaskType;
817 TreeType &tree = grid.tree();
818 LeafNodeType *leaf_node = tree.probeLeaf(probe_coord);
820 NodeMaskType &
mask = leaf_node->getValueMask();
830void set_grid_values_off(openvdb::GridBase &grid_base,
834 to_typed_grid(grid_base, [&](
auto &grid) {
835 auto accessor = grid.getUnsafeAccessor();
838 accessor.setValueOff(voxels[i]);
844void set_tile_values_off(openvdb::GridBase &grid_base,
848 to_typed_grid(grid_base, [&](
auto &grid) {
849 using GridT =
typename std::decay_t<
decltype(grid)>;
850 using TreeT =
typename GridT::TreeType;
851 auto &tree = grid.tree();
853 const auto set_tile_value_off = [&](
auto &
node,
const openvdb::Coord &coord_in_tile) {
854 const openvdb::Index n =
node.coordToOffset(coord_in_tile);
855 node.setValueOffUnsafe(n);
863 const openvdb::CoordBBox
tile =
tiles[i];
864 const openvdb::Coord coord_in_tile =
tile.min();
865 using InternalNode1 =
typename TreeT::RootNodeType::ChildNodeType;
866 using InternalNode2 =
typename InternalNode1::ChildNodeType;
868 if (
auto *
node = tree.template probeNode<InternalNode2>(coord_in_tile)) {
869 set_tile_value_off(*
node, coord_in_tile);
871 else if (
auto *
node = tree.template probeNode<InternalNode1>(coord_in_tile)) {
872 set_tile_value_off(*
node, coord_in_tile);
881void set_mask_leaf_buffer_from_bools(openvdb::BoolGrid &grid,
883 const IndexMask &index_mask,
886 auto accessor = grid.getUnsafeAccessor();
888 index_mask.foreach_index_optimized<
int>([&](
const int i) {
889 const openvdb::Coord &coord = voxels[i];
890 accessor.setValue(coord, values[i]);
894void set_grid_background(openvdb::GridBase &grid_base,
const GPointer value)
896 to_typed_grid(grid_base, [&](
auto &grid) {
897 using GridT = std::decay_t<
decltype(grid)>;
898 using ValueType =
typename GridT::ValueType;
899 auto &tree = grid.tree();
901 BLI_assert(value.type()->size ==
sizeof(ValueType));
902 tree.root().setBackground(*
static_cast<const ValueType *
>(value.get()),
true);
906void set_inactive_values(openvdb::GridBase &grid_base,
const GPointer value)
908 to_typed_grid(grid_base, [&](
auto &grid) {
909 using GridT = std::decay_t<
decltype(grid)>;
910 using ValueType =
typename GridT::ValueType;
911 auto &tree = grid.tree();
913 BLI_assert(value.type()->size ==
sizeof(ValueType));
914 const ValueType &new_value = *
static_cast<const ValueType *
>(value.get());
916 using TreeT =
typename GridT::TreeType;
919 openvdb::tree::LeafManager<TreeT> leaf_manager(tree);
920 leaf_manager.foreach([&](
typename TreeT::LeafNodeType &leaf,
size_t ) {
921 for (
auto iter = leaf.beginValueOff(); iter; ++iter) {
922 iter.setValue(new_value);
926 auto tile_iter = tree.beginValueOff();
927 tile_iter.setMaxDepth(tile_iter.getLeafDepth() - 1);
928 for (; tile_iter; ++tile_iter) {
929 tile_iter.setValue(new_value);
934void prune_inactive(openvdb::GridBase &grid_base)
936 to_typed_grid(grid_base, [&](
auto &grid) { openvdb::tools::pruneInactive(grid.tree()); });
940static void sample_tree_indices(
const bke::OpenvdbTreeType<T> &tree,
944 const IndexMask &
mask,
947 using TreeType = bke::OpenvdbTreeType<T>;
948 using TreeValueT =
typename TreeType::ValueType;
949 using AccessorT =
typename TreeType::ConstUnsafeAccessor;
950 using TraitsT =
typename bke::VolumeGridTraits<T>;
953 AccessorT accessor =
const_cast<TreeType &
>(tree).getConstUnsafeAccessor();
956 TreeValueT value = accessor.getValue(openvdb::Coord(
x[i],
y[i],
z[i]));
957 dst[i] = TraitsT::to_blender(value);
961void sample_tree_indices(
const VolumeGridType grid_type,
962 const openvdb::TreeBase &tree_base,
966 const IndexMask &
mask,
967 GMutableSpan r_values)
970 BKE_volume_grid_type_to_blender_value_type(grid_type, [&]<
typename T>() {
971 if constexpr (is_same_any_v<T, bool, float, int, float3>) {
972 sample_tree_indices<T>(
static_cast<const bke::OpenvdbTreeType<T> &
>(tree_base),
977 r_values.typed<
T>());
982std::optional<VolumeGridType> cpp_type_to_grid_type(
const CPPType &cpp_type)
984 const std::optional<eCustomDataType> cd_type = bke::cpp_type_to_custom_data_type(cpp_type);
988 return bke::custom_data_type_to_volume_grid_type(*cd_type);
992 const openvdb::math::Transform &
transform,
993 const LeafNodeMask &leaf_node_mask,
994 const openvdb::CoordBBox &leaf_bbox,
995 const GetVoxelsFn get_voxels_fn,
998 AlignedBuffer<8192, 8> allocation_buffer;
999 ResourceScope scope(allocation_buffer);
1001 const IndexMask index_mask = IndexMask::from_predicate(
1002 IndexRange(LeafNodeMask::SIZE),
1004 [&](
const int64_t i) { return leaf_node_mask.isOn(i); },
1007 const openvdb::Coord any_voxel_in_leaf = leaf_bbox.min();
1008 MutableSpan<openvdb::Coord> voxels = scope.allocator().allocate_array<openvdb::Coord>(
1009 index_mask.min_array_size());
1010 get_voxels_fn(voxels);
1012 bke::VoxelFieldContext field_context{
transform, voxels};
1013 fn::FieldEvaluator evaluator{field_context, &index_mask};
1015 Array<MutableSpan<bool>> boolean_outputs(fields.
size());
1017 const CPPType &type = fields[i].cpp_type();
1018 to_typed_grid(*output_grids[i], [&](
auto &grid) {
1019 using GridT =
typename std::decay_t<
decltype(grid)>;
1020 using ValueT =
typename GridT::ValueType;
1022 auto &tree = grid.tree();
1023 auto *leaf_node = tree.probeLeaf(any_voxel_in_leaf);
1028 if constexpr (std::is_same_v<ValueT, bool>) {
1029 boolean_outputs[i] = scope.allocator().allocate_array<
bool>(index_mask.min_array_size());
1030 evaluator.add_with_destination(fields[i], boolean_outputs[i]);
1034 ValueT *buffer = leaf_node->buffer().data();
1035 evaluator.add_with_destination(fields[i], GMutableSpan(type, buffer, LeafNodeMask::SIZE));
1040 evaluator.evaluate();
1043 if (!boolean_outputs[i].is_empty()) {
1044 set_mask_leaf_buffer_from_bools(
static_cast<openvdb::BoolGrid &
>(*output_grids[i]),
1053 const openvdb::math::Transform &
transform,
1058 AlignedBuffer<8192, 8> allocation_buffer;
1059 ResourceScope scope(allocation_buffer);
1061 bke::VoxelFieldContext field_context{
transform, voxels};
1062 fn::FieldEvaluator evaluator{field_context, voxels_num};
1064 Array<GMutableSpan> output_values(output_grids.
size());
1066 const CPPType &type = fields[i].cpp_type();
1067 output_values[i] = {type, scope.allocator().allocate_array(type, voxels_num), voxels_num};
1068 evaluator.add_with_destination(fields[i], output_values[i]);
1070 evaluator.evaluate();
1073 set_grid_values(*output_grids[i], output_values[i], voxels);
1078 const openvdb::math::Transform &
transform,
1083 AlignedBuffer<8192, 8> allocation_buffer;
1084 ResourceScope scope(allocation_buffer);
1087 fn::FieldEvaluator evaluator{field_context, tiles_num};
1089 Array<GMutableSpan> output_values(output_grids.
size());
1091 const CPPType &type = fields[i].cpp_type();
1092 output_values[i] = {type, scope.allocator().allocate_array(type, tiles_num), tiles_num};
1093 evaluator.add_with_destination(fields[i], output_values[i]);
1095 evaluator.evaluate();
1098 set_tile_values(*output_grids[i], output_values[i],
tiles);
1103 const openvdb::math::Transform &
transform,
1106 AlignedBuffer<256, 8> allocation_buffer;
1107 ResourceScope scope(allocation_buffer);
1109 static const openvdb::CoordBBox background_space = openvdb::CoordBBox::inf();
1111 fn::FieldEvaluator evaluator(field_context, 1);
1113 Array<GMutablePointer> output_values(output_grids.
size());
1115 const CPPType &type = fields[i].cpp_type();
1116 output_values[i] = {type, scope.allocator().allocate(type)};
1117 evaluator.add_with_destination(fields[i], GMutableSpan{type, output_values[i].get(), 1});
1119 evaluator.evaluate();
1122 set_grid_background(*output_grids[i], output_values[i]);
1126void evaluate_fields_to_grid(
const openvdb::MaskTree &mask_tree,
1127 const openvdb::math::Transform &
transform,
1129 MutableSpan<bke::GVolumeGrid> r_output_grids)
1133 Vector<openvdb::GridBase::Ptr> output_grids(fields.
size());
1135 const std::optional<VolumeGridType> grid_type = cpp_type_to_grid_type(fields[i].cpp_type());
1137 output_grids[i] = create_grid_with_topology(mask_tree,
transform, *grid_type);
1140 parallel_grid_topology_tasks(
1142 [&](
const LeafNodeMask &leaf_node_mask,
1143 const openvdb::CoordBBox &leaf_bbox,
1144 const GetVoxelsFn get_voxels_fn) {
1146 fields,
transform, leaf_node_mask, leaf_bbox, get_voxels_fn, output_grids);
1149 process_voxels(fields,
transform, voxels, output_grids);
1155 process_background(fields,
transform, output_grids);
1158 r_output_grids[i] = bke::GVolumeGrid(std::move(output_grids[i]));
CustomData interface, see also DNA_customdata_types.h.
#define BLI_assert_unreachable()
SIMD_FORCE_INLINE btVector3 transform(const btVector3 &point) const
SIMD_FORCE_INLINE const btScalar & z() const
Return the z value.
constexpr int64_t size() const
constexpr IndexRange index_range() const
void append(const T &value)
ccl_gpu_kernel_postfix ccl_global KernelWorkTile * tiles
const ccl_global KernelWorkTile * tile
void * MEM_new_uninitialized(size_t len, const char *str)
ccl_device_inline float2 mask(const MaskType mask, const float2 a)
float4x4 get_transform_matrix(const VolumeGridData &grid)
std::string get_name(const VolumeGridData &grid)
void count_memory(const VolumeGridData &grid, MemoryCounter &memory)
int get_channels_num(VolumeGridType type)
std::string error_message_from_load(const VolumeGridData &grid)
void load(const VolumeGridData &grid)
void clear_tree(VolumeGridData &grid)
VolumeGridType get_type(const VolumeGridData &grid)
void set_transform_matrix(VolumeGridData &grid, const float4x4 &matrix)
bool is_loaded(const VolumeGridData &grid)
MatBase< float, 4, 4 > float4x4
BMesh const char void * data
@ VOLUME_GRID_VECTOR_FLOAT
@ VOLUME_GRID_VECTOR_DOUBLE
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
static MatBase identity()