BKE_attribute_storage.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2025 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <variant>
 
#include "BLI_function_ref.hh"
#include "BLI_implicit_sharing_ptr.hh"
#include "BLI_memory_counter_fwd.hh"
#include "BLI_string_ref.hh"
#include "BLI_vector_set.hh"
 
#include "DNA_attribute_types.h"
 
struct BlendDataReader;
struct BlendWriter;
struct IDTypeForeachColorFunctionCallback;
namespace blender {
class GPointer;
class CPPType;
class ResourceScope;
}  // namespace blender
 
namespace blender::bke {
 
enum class AttrDomain : int8_t;
enum class AttrType : int16_t;
enum class AttrStorageType : int8_t;

class Attribute {
 public:
  struct ArrayData {
    /* NOTE: Since the shared data pointed to by `sharing_info` knows how to free itself, it often
     * stores the size and type itself. It may be possible to make use of that fact to avoid
     * storing it here, or even vice versa. */
    void *data;
    int64_t size;
    ImplicitSharingPtr<> sharing_info;
    static ArrayData from_value(const GPointer &value, int64_t domain_size);
    static ArrayData from_default_value(const CPPType &type, int64_t domain_size);
    static ArrayData from_uninitialized(const CPPType &type, int64_t domain_size);
    static ArrayData from_constructed(const CPPType &type, int64_t domain_size);
  };

  struct SingleData {
    /* NOTE: For simplicity and to avoid a bit of redundancy, the domain size isn't stored here.
     * It's not necessary to manage a single value. */
    void *value;
    ImplicitSharingPtr<> sharing_info;
    static SingleData from_value(const GPointer &value);
    static SingleData from_default_value(const CPPType &type);
  };
  using DataVariant = std::variant<ArrayData, SingleData>;
  friend AttributeStorage;
 
 private:
  std::string name_;
  AttrDomain domain_;
  AttrType type_;
 
  DataVariant data_;
 
 public:
  StringRefNull name() const;

  AttrDomain domain() const;

  AttrType data_type() const;

  AttrStorageType storage_type() const;

  const DataVariant &data() const;

  DataVariant &data_for_write();

  void assign_data(DataVariant &&data);
};
 
class AttributeStorageRuntime {
  friend AttributeStorage;
  struct AttributeNameGetter {
    StringRef operator()(const std::unique_ptr<Attribute> &value) const
    {
      return value->name();
    }
  };
  CustomIDVectorSet<std::unique_ptr<Attribute>, AttributeNameGetter> attributes;
};
 
class AttributeStorage : public ::AttributeStorage {
 public:
  AttributeStorage();
  AttributeStorage(const AttributeStorage &other);
  AttributeStorage(AttributeStorage &&other);
  AttributeStorage &operator=(const AttributeStorage &other);
  AttributeStorage &operator=(AttributeStorage &&other);
  ~AttributeStorage();

  void foreach(FunctionRef<void(Attribute &)> fn);
  void foreach(FunctionRef<void(const Attribute &)> fn) const;
  void foreach_with_stop(FunctionRef<bool(Attribute &)> fn);
  void foreach_with_stop(FunctionRef<bool(const Attribute &)> fn) const;

  int count() const;

  Attribute &at_index(int index);
  const Attribute &at_index(int index) const;

  int index_of(StringRef name) const;

  Attribute *lookup(StringRef name);
  const Attribute *lookup(StringRef name) const;

  bool remove(StringRef name);

  Attribute &add(std::string name,
                 bke::AttrDomain domain,
                 bke::AttrType data_type,
                 Attribute::DataVariant data);

  std::string unique_name_calc(StringRef name) const;

  void rename(StringRef old_name, std::string new_name);

  void resize(AttrDomain domain, int64_t new_size);

  void blend_read(BlendDataReader &reader);
  struct BlendWriteData {
    ResourceScope &scope;
    Vector<::Attribute, 16> &attributes;
    explicit BlendWriteData(ResourceScope &scope);
  };

  void blend_write(BlendWriter &writer, const BlendWriteData &write_data);

  void foreach_working_space_color(const IDTypeForeachColorFunctionCallback &fn);
 
  void count_memory(MemoryCounter &memory) const;
};

static_assert(sizeof(AttributeStorage) == sizeof(::AttributeStorage));
 
inline StringRefNull Attribute::name() const
{
  return name_;
}
 
inline AttrDomain Attribute::domain() const
{
  return domain_;
}
 
inline AttrType Attribute::data_type() const
{
  return type_;
}
 
inline const Attribute::DataVariant &Attribute::data() const
{
  return data_;
}
 
inline void Attribute::assign_data(DataVariant &&data)
{
  data_ = std::move(data);
}
 
}  // namespace blender::bke
 
inline blender::bke::AttributeStorage &AttributeStorage::wrap()
{
  return *reinterpret_cast<blender::bke::AttributeStorage *>(this);
}
inline const blender::bke::AttributeStorage &AttributeStorage::wrap() const
{
  return *reinterpret_cast<const blender::bke::AttributeStorage *>(this);
}