BKE_volume_grid.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Foundation
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BKE_volume_grid_fwd.hh"
 
#ifdef WITH_OPENVDB
 
#  include <functional>
#  include <mutex>
#  include <optional>
 
#  include "BKE_volume_enums.hh"
#  include "BKE_volume_grid_type_traits.hh"
 
#  include "BLI_implicit_sharing_ptr.hh"
#  include "BLI_string_ref.hh"
 
#  include "openvdb_fwd.hh"
 
namespace blender::bke::volume_grid {
 
struct LazyLoadedGrid {
  std::shared_ptr<openvdb::GridBase> grid;
  ImplicitSharingPtr<> tree_sharing_info;
};
 
class VolumeGridData : public ImplicitSharingMixin {
 private:
  struct AccessToken {
    const VolumeGridData &grid;
 
    AccessToken(const VolumeGridData &grid) : grid(grid) {}
  };
 
  mutable std::mutex mutex_;
  mutable std::shared_ptr<openvdb::GridBase> grid_;
  mutable ImplicitSharingPtr<> tree_sharing_info_;
 
  mutable bool tree_loaded_ = false;
  mutable bool transform_loaded_ = false;
  mutable bool meta_data_loaded_ = false;
 
  std::function<LazyLoadedGrid()> lazy_load_grid_;
  mutable std::string error_message_;
  std::shared_ptr<AccessToken> tree_access_token_;
 
  friend class VolumeTreeAccessToken;
 
  VolumeGridData();
 
 public:
  explicit VolumeGridData(VolumeGridType grid_type);
 
  explicit VolumeGridData(std::shared_ptr<openvdb::GridBase> grid);
 
  explicit VolumeGridData(std::function<LazyLoadedGrid()> lazy_load_grid,
                          std::shared_ptr<openvdb::GridBase> meta_data_and_transform_grid = {});
 
  ~VolumeGridData();
 
  GVolumeGrid copy() const;
 
  const openvdb::GridBase &grid(VolumeTreeAccessToken &r_token) const;
  openvdb::GridBase &grid_for_write(VolumeTreeAccessToken &r_token);
 
  std::shared_ptr<const openvdb::GridBase> grid_ptr(VolumeTreeAccessToken &r_token) const;
  std::shared_ptr<openvdb::GridBase> grid_ptr_for_write(VolumeTreeAccessToken &r_token);
 
  std::string name() const;
  void set_name(StringRef name);
 
  const openvdb::math::Transform &transform() const;
  openvdb::math::Transform &transform_for_write();
 
  VolumeGridType grid_type() const;
 
  std::optional<VolumeGridType> grid_type_without_load() const;
 
  openvdb::GridClass grid_class() const;
 
  bool is_loaded() const;
 
  void count_memory(MemoryCounter &memory) const;
 
  std::string error_message() const;
 
  bool is_reloadable() const;
 
 private:
  void unload_tree_if_possible() const;
 
  void ensure_grid_loaded() const;
  void delete_self();
};
 
class OpenvdbTreeSharingInfo : public ImplicitSharingInfo {
 private:
  std::shared_ptr<openvdb::tree::TreeBase> tree_;
 
 public:
  OpenvdbTreeSharingInfo(std::shared_ptr<openvdb::tree::TreeBase> tree);
 
  static ImplicitSharingPtr<> make(std::shared_ptr<openvdb::tree::TreeBase> tree);
 
  void delete_self_with_data() override;
  void delete_data_only() override;
};
 
class VolumeTreeAccessToken {
 private:
  std::shared_ptr<VolumeGridData::AccessToken> token_;
 
  friend VolumeGridData;
 
 public:
  VolumeTreeAccessToken() = default;
  VolumeTreeAccessToken(const VolumeTreeAccessToken &) = default;
  VolumeTreeAccessToken(VolumeTreeAccessToken &&) = default;
  VolumeTreeAccessToken &operator=(const VolumeTreeAccessToken &) = default;
  VolumeTreeAccessToken &operator=(VolumeTreeAccessToken &&) = default;
  ~VolumeTreeAccessToken();
 
  bool valid_for(const VolumeGridData &grid) const;
 
  void reset();
};
 
class GVolumeGrid {
 protected:
  ImplicitSharingPtr<VolumeGridData> data_;
 
 public:
  GVolumeGrid() = default;
  explicit GVolumeGrid(const VolumeGridData *data);
  explicit GVolumeGrid(std::shared_ptr<openvdb::GridBase> grid);
  explicit GVolumeGrid(VolumeGridType grid_type);
 
  const VolumeGridData &get() const;
 
  VolumeGridData &get_for_write();
 
  const VolumeGridData *release();
 
  const VolumeGridData *operator->() const;
 
  operator bool() const;
 
  template<typename T> VolumeGrid<T> typed() const;
};
 
template<typename T> class VolumeGrid : public GVolumeGrid {
 public:
  using base_type = T;
 
  VolumeGrid() = default;
  explicit VolumeGrid(const VolumeGridData *data);
  explicit VolumeGrid(std::shared_ptr<OpenvdbGridType<T>> grid);
 
  const OpenvdbGridType<T> &grid(VolumeTreeAccessToken &r_token) const;
  OpenvdbGridType<T> &grid_for_write(VolumeTreeAccessToken &r_token);
 
 private:
  void assert_correct_type() const;
};
 
VolumeGridType get_type(const openvdb::GridBase &grid);
 
/* -------------------------------------------------------------------- */
inline GVolumeGrid::GVolumeGrid(const VolumeGridData *data) : data_(data) {}
 
inline const VolumeGridData &GVolumeGrid::get() const
{
  BLI_assert(*this);
  return *data_.get();
}
 
inline const VolumeGridData *GVolumeGrid::release()
{
  return data_.release();
}
 
inline GVolumeGrid::operator bool() const
{
  return bool(data_);
}
 
template<typename T> inline VolumeGrid<T> GVolumeGrid::typed() const
{
  if (data_) {
    data_->add_user();
  }
  return VolumeGrid<T>(data_.get());
}
 
inline const VolumeGridData *GVolumeGrid::operator->() const
{
  BLI_assert(*this);
  return data_.get();
}
 
template<typename T>
inline VolumeGrid<T>::VolumeGrid(const VolumeGridData *data) : GVolumeGrid(data)
{
  this->assert_correct_type();
}
 
template<typename T>
inline VolumeGrid<T>::VolumeGrid(std::shared_ptr<OpenvdbGridType<T>> grid)
    : GVolumeGrid(std::move(grid))
{
  this->assert_correct_type();
}
 
template<typename T>
inline const OpenvdbGridType<T> &VolumeGrid<T>::grid(VolumeTreeAccessToken &r_token) const
{
  return static_cast<const OpenvdbGridType<T> &>(data_->grid(r_token));
}
 
template<typename T>
inline OpenvdbGridType<T> &VolumeGrid<T>::grid_for_write(VolumeTreeAccessToken &r_token)
{
  return static_cast<OpenvdbGridType<T> &>(this->get_for_write().grid_for_write(r_token));
}
 
template<typename T> inline void VolumeGrid<T>::assert_correct_type() const
{
#  ifndef NDEBUG
  if (data_) {
    const VolumeGridType expected_type = VolumeGridTraits<T>::EnumType;
    if (const std::optional<VolumeGridType> actual_type = data_->grid_type_without_load()) {
      BLI_assert(expected_type == *actual_type);
    }
  }
#  endif
}
 
inline bool VolumeTreeAccessToken::valid_for(const VolumeGridData &grid) const
{
  return grid.tree_access_token_ == token_;
}
 
inline void VolumeTreeAccessToken::reset()
{
  token_.reset();
}
 
}  // namespace blender::bke::volume_grid
 
#endif /* WITH_OPENVDB */