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;
namespace blender {
class ResourceScope;
}
 
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;
    /* The number of elements in the array. */
    int64_t size;
    ImplicitSharingPtr<> sharing_info;
  };
  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;
  };
  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();
};
 
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;
 
  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);
 
  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 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_;
}
 
}  // 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);
}