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 <optional>
 
#  include "BKE_volume_enums.hh"
#  include "BKE_volume_grid_type_traits.hh"
 
#  include "BLI_cache_mutex.hh"
#  include "BLI_implicit_sharing_ptr.hh"
#  include "BLI_mutex.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 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_;
 
  mutable CacheMutex active_voxels_mutex_;
  mutable int64_t active_voxels_ = 0;
  mutable CacheMutex active_leaf_voxels_mutex_;
  mutable int64_t active_leaf_voxels_ = 0;
  mutable CacheMutex active_tiles_mutex_;
  mutable int64_t active_tiles_ = 0;
  mutable CacheMutex size_in_bytes_mutex_;
  mutable int64_t size_in_bytes_ = 0;
  mutable CacheMutex active_bounds_mutex_;
  mutable openvdb::CoordBBox active_bounds_;

  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() override;

  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;
 
  void tag_tree_modified() const;
 
  int64_t active_voxels() const;
  int64_t active_leaf_voxels() const;
  int64_t active_tiles() const;
  int64_t size_in_bytes() const;
  const openvdb::CoordBBox &active_bounds() const;
 
 private:
  void unload_tree_if_possible() const;
 
  void ensure_grid_loaded() const;
  void delete_self() override;
};

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::tree::TreeBase &tree);
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_;
}
 
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 */