BKE_instances.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include <optional>
 
#include "BLI_array.hh"
#include "BLI_function_ref.hh"
#include "BLI_index_mask_fwd.hh"
#include "BLI_math_matrix_types.hh"
#include "BLI_memory_counter_fwd.hh"
#include "BLI_shared_cache.hh"
#include "BLI_string_ref.hh"
#include "BLI_vector.hh"
#include "BLI_virtual_array_fwd.hh"
 
#include "BKE_attribute_filter.hh"
#include "BKE_attribute_storage.hh"
 
struct Object;
struct Collection;
namespace blender::bke {
class AttributeAccessor;
class MutableAttributeAccessor;
}  // namespace blender::bke
 
namespace blender::bke {
 
struct GeometrySet;
struct AttributeAccessorFunctions;

class InstanceReference {
 public:
  enum class Type {
    None,
    Object,
    Collection,
    GeometrySet,
  };
 
 private:
  Type type_ = Type::None;
  void *data_ = nullptr;
  std::unique_ptr<GeometrySet> geometry_set_;
 
 public:
  InstanceReference() = default;
  InstanceReference(Object &object);
  InstanceReference(Collection &collection);
  InstanceReference(GeometrySet geometry_set);
  InstanceReference(std::unique_ptr<GeometrySet> geometry_set);
 
  InstanceReference(const InstanceReference &other);
  InstanceReference(InstanceReference &&other);
 
  InstanceReference &operator=(const InstanceReference &other);
  InstanceReference &operator=(InstanceReference &&other);
 
  Type type() const;
  Object &object() const;
  Collection &collection() const;
  GeometrySet &geometry_set();
  const GeometrySet &geometry_set() const;

  void to_geometry_set(GeometrySet &r_geometry_set) const;
 
  StringRefNull name() const;
 
  bool owns_direct_data() const;
  void ensure_owns_direct_data();
 
  void count_memory(MemoryCounter &memory) const;
 
  friend bool operator==(const InstanceReference &a, const InstanceReference &b);
 
  uint64_t hash() const;
};
 
class Instances {
 private:
  Vector<InstanceReference> references_;
 
  int instances_num_ = 0;
 
  bke::AttributeStorage attributes_;

  mutable SharedCache<Array<int>> reference_user_counts_;
 
  /* These unique ids are generated based on the `id` attribute, which might not contain
   * unique ids at all. */
  mutable SharedCache<Array<int>> unique_ids_cache_;
 
 public:
  Instances();
  Instances(Instances &&other);
  Instances(const Instances &other);
  ~Instances();
 
  Instances &operator=(const Instances &other);
  Instances &operator=(Instances &&other);

  void resize(int capacity);

  int add_reference(const InstanceReference &reference);
  int add_new_reference(const InstanceReference &reference);
  std::optional<int> find_reference_handle(const InstanceReference &query);
  void add_instance(int instance_handle, const float4x4 &transform);
 
  Span<InstanceReference> references() const;
  MutableSpan<InstanceReference> references_for_write();
 
  void remove_unused_references();

  void ensure_geometry_instances();
  GeometrySet &geometry_set_from_reference(int reference_index);
 
  Span<int> reference_handles() const;
  MutableSpan<int> reference_handles_for_write();
  Span<float4x4> transforms() const;
  MutableSpan<float4x4> transforms_for_write();
 
  int instances_num() const;
  int references_num() const;

  void remove(const IndexMask &mask, const AttributeFilter &attribute_filter);
  Span<int> unique_ids() const;

  Span<int> reference_user_counts() const;
 
  bke::AttributeAccessor attributes() const;
  bke::MutableAttributeAccessor attributes_for_write();
 
  bke::AttributeStorage &attribute_storage();
  const bke::AttributeStorage &attribute_storage() const;
 
  void foreach_referenced_geometry(
      FunctionRef<void(const GeometrySet &geometry_set)> callback) const;
 
  bool owns_direct_data() const;
  void ensure_owns_direct_data();
 
  void count_memory(MemoryCounter &memory) const;
 
  void tag_reference_handles_changed()
  {
    reference_user_counts_.tag_dirty();
    unique_ids_cache_.tag_dirty();
  }
};
 
VArray<float3> instance_position_varray(const Instances &instances);
VMutableArray<float3> instance_position_varray_for_write(Instances &instances);
const AttributeAccessorFunctions &instance_attribute_accessor_functions();
 
/* -------------------------------------------------------------------- */
 
inline InstanceReference::InstanceReference(std::unique_ptr<GeometrySet> geometry_set)
    : type_(Type::GeometrySet), geometry_set_(std::move(geometry_set))
{
}
 
inline InstanceReference::InstanceReference(Object &object) : type_(Type::Object), data_(&object)
{
}
 
inline InstanceReference::InstanceReference(Collection &collection)
    : type_(Type::Collection), data_(&collection)
{
}
 
inline InstanceReference::InstanceReference(InstanceReference &&other)
    : type_(other.type_), data_(other.data_), geometry_set_(std::move(other.geometry_set_))
{
  other.type_ = Type::None;
  other.data_ = nullptr;
}
 
inline InstanceReference &InstanceReference::operator=(const InstanceReference &other)
{
  if (this == &other) {
    return *this;
  }
  this->~InstanceReference();
  new (this) InstanceReference(other);
  return *this;
}
 
inline InstanceReference &InstanceReference::operator=(InstanceReference &&other)
{
  if (this == &other) {
    return *this;
  }
  this->~InstanceReference();
  new (this) InstanceReference(std::move(other));
  return *this;
}
 
inline InstanceReference::Type InstanceReference::type() const
{
  return type_;
}
 
inline Object &InstanceReference::object() const
{
  BLI_assert(type_ == Type::Object);
  return *(Object *)data_;
}
 
inline Collection &InstanceReference::collection() const
{
  BLI_assert(type_ == Type::Collection);
  return *(Collection *)data_;
}
 
inline GeometrySet &InstanceReference::geometry_set()
{
  BLI_assert(type_ == Type::GeometrySet);
  return *geometry_set_;
}
 
inline const GeometrySet &InstanceReference::geometry_set() const
{
  BLI_assert(type_ == Type::GeometrySet);
  return *geometry_set_;
}
 
inline AttributeStorage &Instances::attribute_storage()
{
  return attributes_;
}
 
inline const AttributeStorage &Instances::attribute_storage() const
{
  return attributes_;
}

 
}  // namespace blender::bke