Geometry Nodes: refactor instances component

The main goal of this refactor is to not store Object/Collection
pointers for every individual instance. Instead instances now
store a handle for the referenced data. The actual Object/Collection
pointers are stored in a new `InstanceReference` class.

This refactor also allows for some better optimizations further down
the line, because one does not have to search through all instances
anymore to find what data is instanced.

Furthermore, this refactor makes it easier to support instancing
`GeometrySet` or any other data that has to be owned by the
`InstancesComponent`.

Differential Revision: https://developer.blender.org/D11125

1 files changed, 87 insertions, 11 deletions

diff --git a/source/blender/blenkernel/BKE_geometry_set.hh b/source/blender/blenkernel/BKE_geometry_set.hh
index 2d0f099e5ce..106af8172d1 100644
--- a/source/blender/blenkernel/BKE_geometry_set.hh
+++ b/source/blender/blenkernel/BKE_geometry_set.hh
@@ -30,6 +30,7 @@
 #include "BLI_map.hh"
 #include "BLI_set.hh"
 #include "BLI_user_counter.hh"
+#include "BLI_vector_set.hh"
 
 #include "BKE_attribute_access.hh"
 #include "BKE_geometry_set.h"
@@ -505,12 +506,81 @@ class CurveComponent : public GeometryComponent {
   const blender::bke::ComponentAttributeProviders *get_attribute_providers() const final;
 };
 
+class InstanceReference {
+ public:
+  enum class Type {
+    /**
+     * An empty instance. This allows an `InstanceReference` to be default constructed without
+     * being in an invalid state. There might also be other use cases that we haven't explored much
+     * yet (such as changing the instance later on, and "disabling" some instances).
+     */
+    None,
+    Object,
+    Collection,
+  };
+
+ private:
+  Type type_ = Type::None;
+  /** Depending on the type this is either null, an Object or Collection pointer. */
+  void *data_ = nullptr;
+
+ public:
+  InstanceReference() = default;
+
+  InstanceReference(Object &object) : type_(Type::Object), data_(&object)
+  {
+  }
+
+  InstanceReference(Collection &collection) : type_(Type::Collection), data_(&collection)
+  {
+  }
+
+  Type type() const
+  {
+    return type_;
+  }
+
+  Object &object() const
+  {
+    BLI_assert(type_ == Type::Object);
+    return *(Object *)data_;
+  }
+
+  Collection &collection() const
+  {
+    BLI_assert(type_ == Type::Collection);
+    return *(Collection *)data_;
+  }
+
+  uint64_t hash() const
+  {
+    return blender::get_default_hash(data_);
+  }
+
+  friend bool operator==(const InstanceReference &a, const InstanceReference &b)
+  {
+    return a.data_ == b.data_;
+  }
+};
+
 /** A geometry component that stores instances. */
 class InstancesComponent : public GeometryComponent {
  private:
-  blender::Vector<blender::float4x4> transforms_;
-  blender::Vector<int> ids_;
-  blender::Vector<InstancedData> instanced_data_;
+  /**
+   * Indexed set containing information about the data that is instanced.
+   * Actual instances store an index ("handle") into this set.
+   */
+  blender::VectorSet<InstanceReference> references_;
+
+  /** Index into `references_`. Determines what data is instanced. */
+  blender::Vector<int> instance_reference_handles_;
+  /** Transformation of the instances. */
+  blender::Vector<blender::float4x4> instance_transforms_;
+  /**
+   * IDs of the instances. They are used for consistency over multiple frames for things like
+   * motion blur.
+   */
+  blender::Vector<int> instance_ids_;
 
   /* These almost unique ids are generated based on `ids_`, which might not contain unique ids at
    * all. They are *almost* unique, because under certain very unlikely circumstances, they are not
@@ -525,14 +595,20 @@ class InstancesComponent : public GeometryComponent {
   GeometryComponent *copy() const override;
 
   void clear();
-  void add_instance(Object *object, blender::float4x4 transform, const int id = -1);
-  void add_instance(Collection *collection, blender::float4x4 transform, const int id = -1);
-  void add_instance(InstancedData data, blender::float4x4 transform, const int id = -1);
-
-  blender::Span<InstancedData> instanced_data() const;
-  blender::Span<blender::float4x4> transforms() const;
-  blender::Span<int> ids() const;
-  blender::MutableSpan<blender::float4x4> transforms();
+
+  void reserve(int min_capacity);
+
+  int add_reference(InstanceReference reference);
+  void add_instance(int instance_handle, const blender::float4x4 &transform, const int id = -1);
+
+  blender::Span<InstanceReference> references() const;
+
+  blender::Span<int> instance_reference_handles() const;
+  blender::MutableSpan<blender::float4x4> instance_transforms();
+  blender::Span<blender::float4x4> instance_transforms() const;
+  blender::MutableSpan<int> instance_ids();
+  blender::Span<int> instance_ids() const;
+
   int instances_amount() const;
 
   blender::Span<int> almost_unique_ids() const;