Blender V5.3
BKE_volume_grid.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Foundation
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
10
12
13#ifdef WITH_OPENVDB
14
15# include <functional>
16# include <optional>
17
18# include "BKE_volume_enums.hh"
20
21# include "BLI_cache_mutex.hh"
22# include "BLI_cpp_type.hh"
24# include "BLI_mutex.hh"
25# include "BLI_string_ref.hh"
26
27# include "openvdb_fwd.hh"
28
30
35struct LazyLoadedGrid {
41 std::shared_ptr<openvdb::GridBase> grid;
42 ImplicitSharingPtr<> tree_sharing_info;
43};
44
71class VolumeGridData : public ImplicitSharingMixin {
72 private:
76 struct AccessToken {
77 const VolumeGridData &grid;
78
79 AccessToken(const VolumeGridData &grid) : grid(grid) {}
80 };
81
85 mutable Mutex mutex_;
101 mutable std::shared_ptr<openvdb::GridBase> grid_;
105 mutable ImplicitSharingPtr<> tree_sharing_info_;
106
108 mutable bool tree_loaded_ = false;
110 mutable bool transform_loaded_ = false;
112 mutable bool meta_data_loaded_ = false;
113
117 std::function<LazyLoadedGrid()> lazy_load_grid_;
121 mutable std::string error_message_;
122
123 mutable CacheMutex active_voxels_mutex_;
124 mutable int64_t active_voxels_ = 0;
125 mutable CacheMutex active_leaf_voxels_mutex_;
126 mutable int64_t active_leaf_voxels_ = 0;
127 mutable CacheMutex active_tiles_mutex_;
128 mutable int64_t active_tiles_ = 0;
129 mutable CacheMutex size_in_bytes_mutex_;
130 mutable int64_t size_in_bytes_ = 0;
131 mutable CacheMutex active_bounds_mutex_;
132 mutable openvdb::CoordBBox active_bounds_;
133
140 std::shared_ptr<AccessToken> tree_access_token_;
141
142 friend class VolumeTreeAccessToken;
143
145 VolumeGridData();
146
147 public:
152 explicit VolumeGridData(VolumeGridType grid_type);
153
158 explicit VolumeGridData(std::shared_ptr<openvdb::GridBase> grid);
159
169 explicit VolumeGridData(std::function<LazyLoadedGrid()> lazy_load_grid,
170 std::shared_ptr<openvdb::GridBase> meta_data_and_transform_grid = {});
171
172 ~VolumeGridData() override;
173
181 GVolumeGrid copy() const;
182
187 const openvdb::GridBase &grid(VolumeTreeAccessToken &r_token) const;
192 openvdb::GridBase &grid_for_write(VolumeTreeAccessToken &r_token);
193
199 std::shared_ptr<const openvdb::GridBase> grid_ptr(VolumeTreeAccessToken &r_token) const;
200 std::shared_ptr<openvdb::GridBase> grid_ptr_for_write(VolumeTreeAccessToken &r_token);
201
205 std::string name() const;
209 void set_name(StringRef name);
210
215 const openvdb::math::Transform &transform() const;
220 openvdb::math::Transform &transform_for_write();
221
225 VolumeGridType grid_type() const;
226
231 std::optional<VolumeGridType> grid_type_without_load() const;
232
236 openvdb::GridClass grid_class() const;
237
241 bool is_loaded() const;
242
246 const CPPType *cpp_type() const;
247
248 void count_memory(MemoryCounter &memory) const;
249
253 std::string error_message() const;
254
258 bool is_reloadable() const;
259
260 void tag_tree_modified() const;
261
262 int64_t active_voxels() const;
263 int64_t active_leaf_voxels() const;
264 int64_t active_tiles() const;
265 int64_t size_in_bytes() const;
266 const openvdb::CoordBBox &active_bounds() const;
267
268 private:
272 void unload_tree_if_possible() const;
273
274 void ensure_grid_loaded() const;
275 void delete_self() override;
276};
277
283class OpenvdbTreeSharingInfo : public ImplicitSharingInfo {
284 private:
285 std::shared_ptr<openvdb::tree::TreeBase> tree_;
286
287 public:
288 OpenvdbTreeSharingInfo(std::shared_ptr<openvdb::tree::TreeBase> tree);
289
290 static ImplicitSharingPtr<> make(std::shared_ptr<openvdb::tree::TreeBase> tree);
291
292 void delete_self_with_data() override;
293 void delete_data_only() override;
294};
295
296class VolumeTreeAccessToken {
297 private:
298 std::shared_ptr<VolumeGridData::AccessToken> token_;
299
300 friend VolumeGridData;
301
302 public:
308 VolumeTreeAccessToken() = default;
309 VolumeTreeAccessToken(const VolumeTreeAccessToken &) = default;
310 VolumeTreeAccessToken(VolumeTreeAccessToken &&) = default;
311 VolumeTreeAccessToken &operator=(const VolumeTreeAccessToken &) = default;
312 VolumeTreeAccessToken &operator=(VolumeTreeAccessToken &&) = default;
313 ~VolumeTreeAccessToken();
314
316 bool valid_for(const VolumeGridData &grid) const;
317
319 void reset();
320};
321
326class GVolumeGrid {
327 protected:
328 ImplicitSharingPtr<VolumeGridData> data_;
329
330 public:
334 GVolumeGrid() = default;
339 explicit GVolumeGrid(const VolumeGridData *data);
343 explicit GVolumeGrid(std::shared_ptr<openvdb::GridBase> grid);
348 explicit GVolumeGrid(VolumeGridType grid_type);
349
353 const VolumeGridData &get() const;
354
359 VolumeGridData &get_for_write();
360
364 const VolumeGridData *release();
365
367 const VolumeGridData *operator->() const;
368
370 operator bool() const;
371
373 template<typename T> const VolumeGrid<T> &typed() const;
374 template<typename T> VolumeGrid<T> &typed();
375};
376
381template<typename T> class VolumeGrid {
382 public:
383 using base_type = T;
384 using generic_type = GVolumeGrid;
385
386 private:
387 GVolumeGrid grid_;
388
389 friend GVolumeGrid;
390
391 public:
392 VolumeGrid() = default;
393 explicit VolumeGrid(const VolumeGridData *data);
394 explicit VolumeGrid(std::shared_ptr<OpenvdbGridType<T>> grid);
395
396 operator const GVolumeGrid &() const;
397 operator GVolumeGrid &();
398
402 const OpenvdbGridType<T> &grid(VolumeTreeAccessToken &r_token) const;
403 OpenvdbGridType<T> &grid_for_write(VolumeTreeAccessToken &r_token);
404 operator bool() const;
405 const VolumeGridData *operator->() const;
406 const VolumeGridData &get() const;
407
408 private:
409 void assert_correct_type() const;
410};
411
415VolumeGridType get_type(const openvdb::tree::TreeBase &tree);
419VolumeGridType get_type(const openvdb::GridBase &grid);
420
421/* -------------------------------------------------------------------- */
424
425inline GVolumeGrid::GVolumeGrid(const VolumeGridData *data) : data_(data) {}
426
427inline const VolumeGridData &GVolumeGrid::get() const
428{
429 BLI_assert(*this);
430 return *data_;
431}
432
433template<typename T> inline const VolumeGridData &VolumeGrid<T>::get() const
434{
435 return grid_.get();
436}
437
438inline const VolumeGridData *GVolumeGrid::release()
439{
440 return data_.release();
441}
442
443inline GVolumeGrid::operator bool() const
444{
445 return bool(data_);
446}
447
448template<typename T> inline VolumeGrid<T>::operator bool() const
449{
450 return bool(grid_);
451}
452
453template<typename T> inline const VolumeGrid<T> &GVolumeGrid::typed() const
454{
455 static_assert(sizeof(GVolumeGrid) == sizeof(VolumeGrid<T>));
456 const auto &typed_grid = reinterpret_cast<const VolumeGrid<T> &>(*this);
457 typed_grid.assert_correct_type();
458 return typed_grid;
459}
460
461template<typename T> inline VolumeGrid<T> &GVolumeGrid::typed()
462{
463 static_assert(sizeof(GVolumeGrid) == sizeof(VolumeGrid<T>));
464 auto &typed_grid = reinterpret_cast<VolumeGrid<T> &>(*this);
465 typed_grid.assert_correct_type();
466 return typed_grid;
467}
468
469template<typename T> inline VolumeGrid<T>::operator const GVolumeGrid &() const
470{
471 return grid_;
472}
473
474template<typename T> inline VolumeGrid<T>::operator GVolumeGrid &()
475{
476 return grid_;
477}
478
479inline const VolumeGridData *GVolumeGrid::operator->() const
480{
481 BLI_assert(*this);
482 return data_.get();
483}
484
485template<typename T> inline const VolumeGridData *VolumeGrid<T>::operator->() const
486{
487 BLI_assert(*this);
488 return grid_.GVolumeGrid::operator->();
489}
490
491template<typename T> inline VolumeGrid<T>::VolumeGrid(const VolumeGridData *data) : grid_(data)
492{
493 this->assert_correct_type();
494}
495
496template<typename T>
497inline VolumeGrid<T>::VolumeGrid(std::shared_ptr<OpenvdbGridType<T>> grid) : grid_(std::move(grid))
498{
499 this->assert_correct_type();
500}
501
502template<typename T>
503inline const OpenvdbGridType<T> &VolumeGrid<T>::grid(VolumeTreeAccessToken &r_token) const
504{
505 return static_cast<const OpenvdbGridType<T> &>(grid_->grid(r_token));
506}
507
508template<typename T>
509inline OpenvdbGridType<T> &VolumeGrid<T>::grid_for_write(VolumeTreeAccessToken &r_token)
510{
511 return static_cast<OpenvdbGridType<T> &>(grid_.get_for_write().grid_for_write(r_token));
512}
513
514template<typename T> inline void VolumeGrid<T>::assert_correct_type() const
515{
516# ifndef NDEBUG
517 if (grid_) {
518 const VolumeGridType expected_type = VolumeGridTraits<T>::EnumType;
519 if (const std::optional<VolumeGridType> actual_type = grid_->grid_type_without_load()) {
520 BLI_assert(expected_type == *actual_type);
521 }
522 }
523# endif
524}
525
526inline bool VolumeTreeAccessToken::valid_for(const VolumeGridData &grid) const
527{
528 return grid.tree_access_token_ == token_;
529}
530
531inline void VolumeTreeAccessToken::reset()
532{
533 token_.reset();
534}
535
537
538} // namespace blender::bke::volume_grid
539
540#endif /* WITH_OPENVDB */
#define BLI_assert(a)
SIMD_FORCE_INLINE btVector3 transform(const btVector3 &point) const
long long int int64_t
btGeneric6DofConstraint & operator=(btGeneric6DofConstraint &other)
void reset()
const void * ImplicitSharingInfo
#define T
struct bMotionPath * copy(const struct bMotionPath *mpath_src)
void count_memory(const VolumeGridData &grid, MemoryCounter &memory)
VolumeGridType get_type(const VolumeGridData &grid)
bool is_loaded(const VolumeGridData &grid)
std::shared_ptr< const T > get(const GenericKey &key, FunctionRef< std::unique_ptr< T >()> compute_fn)
BMesh const char void * data
std::mutex Mutex
Definition BLI_mutex.hh:51