BKE_geometry_set.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <iosfwd>
#include <mutex>
 
#include "BLI_bounds_types.hh"
#include "BLI_function_ref.hh"
#include "BLI_implicit_sharing_ptr.hh"
#include "BLI_map.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_memory_counter_fwd.hh"
 
/* For #Map. */
#include "BKE_attribute.hh"
 
struct Curves;
struct Curve;
struct Mesh;
struct PointCloud;
struct Volume;
struct GreasePencil;
namespace blender::bke {
struct AttributeKind;
class AttributeAccessor;
struct AttributeMetaData;
class ComponentAttributeProviders;
class CurvesEditHints;
class Instances;
class GeometryComponent;
class GreasePencilEditHints;
class MutableAttributeAccessor;
enum class AttrDomain : int8_t;
struct GizmoEditHints;
}  // namespace blender::bke
 
namespace blender::bke {
 
#define GEO_COMPONENT_TYPE_ENUM_SIZE 7
 
enum class GeometryOwnershipType {
  /* The geometry is owned. This implies that it can be changed. */
  Owned = 0,
  /* The geometry can be changed, but someone else is responsible for freeing it. */
  Editable = 1,
  /* The geometry cannot be changed and someone else is responsible for freeing it. */
  ReadOnly = 2,
};
 
using GeometryComponentPtr = ImplicitSharingPtr<GeometryComponent>;
 
class GeometryComponent : public ImplicitSharingMixin {
 public:
  enum class Type {
    Mesh = 0,
    PointCloud = 1,
    Instance = 2,
    Volume = 3,
    Curve = 4,
    Edit = 5,
    GreasePencil = 6,
  };
 
 private:
  Type type_;
 
 public:
  GeometryComponent(Type type);
  virtual ~GeometryComponent() = default;
  static GeometryComponentPtr create(Type component_type);
 
  int attribute_domain_size(AttrDomain domain) const;
 
  virtual std::optional<AttributeAccessor> attributes() const;
  virtual std::optional<MutableAttributeAccessor> attributes_for_write();
 
  virtual void count_memory(MemoryCounter &memory) const;
 
  virtual GeometryComponentPtr copy() const = 0;
 
  virtual void clear() = 0;
 
  /* Direct data is everything except for instances of objects/collections.
   * If this returns true, the geometry set can be cached and is still valid after e.g. modifier
   * evaluation ends. Instances can only be valid as long as the data they instance is valid. */
  virtual bool owns_direct_data() const = 0;
  virtual void ensure_owns_direct_data() = 0;
 
  Type type() const;
 
  virtual bool is_empty() const;
 
 private:
  void delete_self() override;
  void delete_data_only() override;
};
 
template<typename T>
inline constexpr bool is_geometry_component_v = std::is_base_of_v<GeometryComponent, T>;
 
struct GeometrySet {
 private:
  /* Indexed by #GeometryComponent::Type. */
  std::array<GeometryComponentPtr, GEO_COMPONENT_TYPE_ENUM_SIZE> components_;
 
 public:
  std::string name;
 
  GeometrySet();
  GeometrySet(const GeometrySet &other);
  GeometrySet(GeometrySet &&other);
  ~GeometrySet();
  GeometrySet &operator=(const GeometrySet &other);
  GeometrySet &operator=(GeometrySet &&other);
 
  GeometryComponent &get_component_for_write(GeometryComponent::Type component_type);
  template<typename Component> Component &get_component_for_write()
  {
    BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
    return static_cast<Component &>(this->get_component_for_write(Component::static_type));
  }
 
  const GeometryComponent *get_component(GeometryComponent::Type component_type) const;
  template<typename Component> const Component *get_component() const
  {
    BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
    return static_cast<const Component *>(get_component(Component::static_type));
  }
 
  bool has(const GeometryComponent::Type component_type) const;
  template<typename Component> bool has() const
  {
    BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
    return this->has(Component::static_type);
  }
 
  template<typename Component> bool has_component() const
  {
    BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
    return components_[int(Component::static_type)];
  }
 
  void remove(const GeometryComponent::Type component_type);
  template<typename Component> void remove()
  {
    BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
    return this->remove(Component::static_type);
  }
 
  void keep_only(Span<GeometryComponent::Type> component_types);
  void keep_only_during_modify(Span<GeometryComponent::Type> component_types);
  void remove_geometry_during_modify();
 
  void add(const GeometryComponent &component);
 
  Vector<const GeometryComponent *> get_components() const;
 
  std::optional<Bounds<float3>> compute_boundbox_without_instances() const;
 
  friend std::ostream &operator<<(std::ostream &stream, const GeometrySet &geometry_set);
 
  void clear();
 
  bool owns_direct_data() const;
  void ensure_owns_direct_data();
  void ensure_owns_all_data();
 
  using AttributeForeachCallback = FunctionRef<void(StringRef attribute_id,
                                                    const AttributeMetaData &meta_data,
                                                    const GeometryComponent &component)>;
 
  void attribute_foreach(Span<GeometryComponent::Type> component_types,
                         bool include_instances,
                         AttributeForeachCallback callback) const;
 
  static void propagate_attributes_from_layer_to_instances(
      const AttributeAccessor src_attributes,
      MutableAttributeAccessor dst_attributes,
      const AttributeFilter &attribute_filter);
 
  void gather_attributes_for_propagation(Span<GeometryComponent::Type> component_types,
                                         GeometryComponent::Type dst_component_type,
                                         bool include_instances,
                                         const AttributeFilter &attribute_filter,
                                         Map<StringRef, AttributeKind> &r_attributes) const;
 
  Vector<GeometryComponent::Type> gather_component_types(bool include_instances,
                                                         bool ignore_empty) const;
 
  using ForeachSubGeometryCallback = FunctionRef<void(GeometrySet &geometry_set)>;
 
  void modify_geometry_sets(ForeachSubGeometryCallback callback);
 
  /* Utility methods for creation. */
  static GeometrySet from_mesh(Mesh *mesh,
                               GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  static GeometrySet from_volume(Volume *volume,
                                 GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  static GeometrySet from_pointcloud(
      PointCloud *pointcloud, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  static GeometrySet from_curves(Curves *curves,
                                 GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  static GeometrySet from_instances(
      Instances *instances, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  static GeometrySet from_grease_pencil(
      GreasePencil *grease_pencil, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
 
  /* Utility methods for access. */
  bool has_mesh() const;
  bool has_pointcloud() const;
  bool has_instances() const;
  bool has_volume() const;
  bool has_curves() const;
  bool has_realized_data() const;
  bool has_grease_pencil() const;
  bool is_empty() const;
 
  const Mesh *get_mesh() const;
  const PointCloud *get_pointcloud() const;
  const Volume *get_volume() const;
  const Curves *get_curves() const;
  const Instances *get_instances() const;
  const CurvesEditHints *get_curve_edit_hints() const;
  const GizmoEditHints *get_gizmo_edit_hints() const;
  const GreasePencil *get_grease_pencil() const;
 
  Mesh *get_mesh_for_write();
  PointCloud *get_pointcloud_for_write();
  Volume *get_volume_for_write();
  Curves *get_curves_for_write();
  Instances *get_instances_for_write();
  CurvesEditHints *get_curve_edit_hints_for_write();
  GizmoEditHints *get_gizmo_edit_hints_for_write();
  GreasePencil *get_grease_pencil_for_write();
 
  /* Utility methods for replacement. */
  void replace_mesh(Mesh *mesh, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  void replace_pointcloud(PointCloud *pointcloud,
                          GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  void replace_volume(Volume *volume,
                      GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  void replace_curves(Curves *curves,
                      GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  void replace_instances(Instances *instances,
                         GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  void replace_grease_pencil(GreasePencil *grease_pencil,
                             GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
 
  friend bool operator==(const GeometrySet &a, const GeometrySet &b)
  {
    /* This compares only the component pointers, not the actual geometry data. */
    return Span(a.components_) == Span(b.components_) && a.name == b.name;
  }
 
  uint64_t hash() const
  {
    /* This should have the same data that's also taken into account in #operator==. */
    return get_default_hash(Span(components_), this->name);
  }
 
  void count_memory(MemoryCounter &memory) const;
 
 private:
  GeometryComponent *get_component_ptr(GeometryComponent::Type type);
  template<typename Component> Component *get_component_ptr()
  {
    BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
    return static_cast<Component *>(get_component_ptr(Component::static_type));
  }
};
 
class MeshComponent : public GeometryComponent {
 private:
  Mesh *mesh_ = nullptr;
  GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
 
 public:
  MeshComponent();
  MeshComponent(Mesh *mesh, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  ~MeshComponent();
  GeometryComponentPtr copy() const override;
 
  void clear() override;
  bool has_mesh() const;
  void replace(Mesh *mesh, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  Mesh *release();
 
  const Mesh *get() const;
  Mesh *get_for_write();
 
  bool is_empty() const final;
 
  bool owns_direct_data() const override;
  void ensure_owns_direct_data() override;
 
  void count_memory(MemoryCounter &memory) const override;
 
  static constexpr inline GeometryComponent::Type static_type = Type::Mesh;
 
  std::optional<AttributeAccessor> attributes() const final;
  std::optional<MutableAttributeAccessor> attributes_for_write() final;
};
 
class PointCloudComponent : public GeometryComponent {
 private:
  PointCloud *pointcloud_ = nullptr;
  GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
 
 public:
  PointCloudComponent();
  PointCloudComponent(PointCloud *pointcloud,
                      GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  ~PointCloudComponent();
  GeometryComponentPtr copy() const override;
 
  void clear() override;
  bool has_pointcloud() const;
  void replace(PointCloud *pointcloud,
               GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  PointCloud *release();
 
  const PointCloud *get() const;
  PointCloud *get_for_write();
 
  bool is_empty() const final;
 
  bool owns_direct_data() const override;
  void ensure_owns_direct_data() override;
 
  void count_memory(MemoryCounter &memory) const override;
 
  std::optional<AttributeAccessor> attributes() const final;
  std::optional<MutableAttributeAccessor> attributes_for_write() final;
 
  static constexpr inline GeometryComponent::Type static_type = Type::PointCloud;
};
 
class CurveComponent : public GeometryComponent {
 private:
  Curves *curves_ = nullptr;
  GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
 
  mutable Curve *curve_for_render_ = nullptr;
  mutable std::mutex curve_for_render_mutex_;
 
 public:
  CurveComponent();
  CurveComponent(Curves *curve, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  ~CurveComponent();
  GeometryComponentPtr copy() const override;
 
  void clear() override;
  bool has_curves() const;
  void replace(Curves *curve, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  Curves *release();
 
  const Curves *get() const;
  Curves *get_for_write();
 
  bool is_empty() const final;
 
  bool owns_direct_data() const override;
  void ensure_owns_direct_data() override;
 
  void count_memory(MemoryCounter &memory) const override;
 
  const Curve *get_curve_for_render() const;
 
  std::optional<AttributeAccessor> attributes() const final;
  std::optional<MutableAttributeAccessor> attributes_for_write() final;
 
  static constexpr inline GeometryComponent::Type static_type = Type::Curve;
};
 
class InstancesComponent : public GeometryComponent {
 private:
  Instances *instances_ = nullptr;
  GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
 
 public:
  InstancesComponent();
  InstancesComponent(Instances *instances,
                     GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  ~InstancesComponent();
  GeometryComponentPtr copy() const override;
 
  void clear() override;
 
  const Instances *get() const;
  Instances *get_for_write();
 
  void replace(Instances *instances,
               GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
 
  bool is_empty() const final;
 
  Instances *release();
 
  bool owns_direct_data() const override;
  void ensure_owns_direct_data() override;
 
  void count_memory(MemoryCounter &memory) const override;
 
  std::optional<AttributeAccessor> attributes() const final;
  std::optional<MutableAttributeAccessor> attributes_for_write() final;
 
  static constexpr inline GeometryComponent::Type static_type = Type::Instance;
};
 
class VolumeComponent : public GeometryComponent {
 private:
  Volume *volume_ = nullptr;
  GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
 
 public:
  VolumeComponent();
  ~VolumeComponent();
  GeometryComponentPtr copy() const override;
 
  void clear() override;
  bool has_volume() const;
  void replace(Volume *volume, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  Volume *release();
 
  const Volume *get() const;
  Volume *get_for_write();
 
  bool owns_direct_data() const override;
  void ensure_owns_direct_data() override;
 
  void count_memory(MemoryCounter &memory) const override;
 
  static constexpr inline GeometryComponent::Type static_type = Type::Volume;
};
 
class GeometryComponentEditData final : public GeometryComponent {
 public:
  std::unique_ptr<CurvesEditHints> curves_edit_hints_;
  std::unique_ptr<GreasePencilEditHints> grease_pencil_edit_hints_;
  std::unique_ptr<GizmoEditHints> gizmo_edit_hints_;
 
  GeometryComponentEditData();
 
  GeometryComponentPtr copy() const final;
  bool owns_direct_data() const final;
  void ensure_owns_direct_data() final;
 
  void clear() override;
 
  static void remember_deformed_positions_if_necessary(GeometrySet &geometry);
 
  static constexpr inline GeometryComponent::Type static_type = GeometryComponent::Type::Edit;
};
 
class GreasePencilComponent : public GeometryComponent {
 private:
  GreasePencil *grease_pencil_ = nullptr;
  GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
 
 public:
  GreasePencilComponent();
  ~GreasePencilComponent();
  GeometryComponentPtr copy() const override;
 
  void clear() override;
  bool has_grease_pencil() const;
  void replace(GreasePencil *grease_pencil,
               GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
  GreasePencil *release();
 
  const GreasePencil *get() const;
  GreasePencil *get_for_write();
 
  bool is_empty() const final;
 
  bool owns_direct_data() const override;
  void ensure_owns_direct_data() override;
 
  static constexpr inline GeometryComponent::Type static_type = Type::GreasePencil;
 
  std::optional<AttributeAccessor> attributes() const final;
  std::optional<MutableAttributeAccessor> attributes_for_write() final;
};
 
bool attribute_is_builtin_on_component_type(const GeometryComponent::Type type, StringRef name);
 
}  // namespace blender::bke