BKE_collection.hh

Go to the documentation of this file.

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

 
#include "BLI_ghash.h"
#include "BLI_iterator.h"
#include "BLI_sys_types.h"
 
#include "DNA_listBase.h"
#include "DNA_userdef_enums.h"
 
/* Structs */
 
struct BLI_Iterator;
struct Base;
struct BlendDataReader;
struct BlendWriter;
struct Collection;
struct ID;
struct CollectionChild;
struct CollectionExport;
struct GHash;
struct Main;
struct Object;
struct Scene;
struct ViewLayer;

enum {
  COLLECTION_TAG_RELATION_REBUILD = (1 << 0),
  COLLECTION_TAG_COLLECTION_OBJECT_DIRTY = (1 << 1),
};
 
namespace blender::bke {
 
struct CollectionRuntime {
  ListBase object_cache = {};

  ListBase object_cache_instanced = {};

  ListBase parents = {};

  GHash *gobject_hash = nullptr;
 
  uint8_t tag = 0;
};
 
}  // namespace blender::bke
 
struct CollectionParent {
  struct CollectionParent *next, *prev;
  struct Collection *collection;
};
 
/* Collections */

Collection *BKE_collection_add(Main *bmain,
                               Collection *collection_parent,
                               const char *name_custom);
void BKE_collection_add_from_object(Main *bmain,
                                    Scene *scene,
                                    const Object *ob_src,
                                    Collection *collection_dst);
void BKE_collection_add_from_collection(Main *bmain,
                                        Scene *scene,
                                        Collection *collection_src,
                                        Collection *collection_dst);
void BKE_collection_free_data(Collection *collection);

CollectionExport *BKE_collection_exporter_add(Collection *collection, char *idname, char *label);

void BKE_collection_exporter_remove(Collection *collection, CollectionExport *data);

bool BKE_collection_exporter_move(Collection *collection, const int from, const int to);

void BKE_collection_exporter_name_set(const ListBase *exporters,
                                      CollectionExport *data,
                                      const char *newname);

void BKE_collection_exporter_free_data(CollectionExport *data);

bool BKE_collection_delete(Main *bmain, Collection *collection, bool hierarchy);

Collection *BKE_collection_duplicate(Main *bmain,
                                     Collection *parent,
                                     CollectionChild *child_old,
                                     Collection *collection,
                                     eDupli_ID_Flags duplicate_flags,
                                     /*eLibIDDuplicateFlags*/ uint duplicate_options);
 
/* Master Collection for Scene */
 
#define BKE_SCENE_COLLECTION_NAME "Scene Collection"
Collection *BKE_collection_master_add(Scene *scene);

bool BKE_collection_contains_geometry_recursive(const Collection *collection);
 
/* Collection Objects */
 
bool BKE_collection_has_object(Collection *collection, const Object *ob);
bool BKE_collection_has_object_recursive(Collection *collection, Object *ob);
bool BKE_collection_has_object_recursive_instanced(Collection *collection, Object *ob);
bool BKE_collection_has_object_recursive_instanced_orig_id(Collection *collection_eval,
                                                           Object *object_eval);
Collection *BKE_collection_object_find(Main *bmain,
                                       Scene *scene,
                                       Collection *collection,
                                       Object *ob);
 
CollectionChild *BKE_collection_child_find(Collection *parent, Collection *collection);
 
bool BKE_collection_is_empty(const Collection *collection);

bool BKE_collection_object_add(Main *bmain, Collection *collection, Object *ob);

bool BKE_collection_viewlayer_object_add(Main *bmain,
                                         const ViewLayer *view_layer,
                                         Collection *collection,
                                         Object *ob);

bool BKE_collection_object_add_notest(Main *bmain, Collection *collection, Object *ob);
void BKE_collection_object_add_from(Main *bmain, Scene *scene, Object *ob_src, Object *ob_dst);
bool BKE_collection_object_remove(Main *bmain, Collection *collection, Object *ob, bool free_us);
bool BKE_collection_object_replace(Main *bmain,
                                   Collection *collection,
                                   Object *ob_old,
                                   Object *ob_new);

void BKE_collection_object_move(
    Main *bmain, Scene *scene, Collection *collection_dst, Collection *collection_src, Object *ob);

bool BKE_scene_collections_object_remove(Main *bmain, Scene *scene, Object *ob, bool free_us);

void BKE_collections_object_remove_invalids(Main *bmain);

void BKE_collections_child_remove_nulls(Main *bmain,
                                        Collection *parent_collection,
                                        Collection *child_collection);
 
/* Dependencies. */
 
bool BKE_collection_is_in_scene(Collection *collection);
void BKE_collections_after_lib_link(Main *bmain);
bool BKE_collection_object_cyclic_check(Main *bmain, Object *object, Collection *collection);
 
/* Object list cache. */
 
ListBase BKE_collection_object_cache_get(Collection *collection);
ListBase BKE_collection_object_cache_instanced_get(Collection *collection);
void BKE_collection_object_cache_free(const Main *bmain,
                                      Collection *collection,
                                      const int id_create_flag);
void BKE_main_collections_object_cache_free(const Main *bmain);
 
Base *BKE_collection_or_layer_objects(const Scene *scene,
                                      ViewLayer *view_layer,
                                      Collection *collection);
 
/* Editing. */

Collection *BKE_collection_from_session_uid(Scene *scene, uint64_t session_uid);
Collection *BKE_collection_from_session_uid(Main *bmain,
                                            uint64_t session_uid,
                                            Scene **r_scene = nullptr);

void BKE_collection_new_name_get(Collection *collection_parent,
                                 char r_name[/*MAX_ID_NAME - 2*/ 256]);
const char *BKE_collection_ui_name_get(Collection *collection);
bool BKE_collection_objects_select(const Scene *scene,
                                   ViewLayer *view_layer,
                                   Collection *collection,
                                   bool deselect);
 
/* Collection children */
 
bool BKE_collection_child_add(Main *bmain, Collection *parent, Collection *child);
 
bool BKE_collection_child_add_no_sync(Main *bmain, Collection *parent, Collection *child);
 
bool BKE_collection_child_remove(Main *bmain, Collection *parent, Collection *child);
 
bool BKE_collection_move(Main *bmain,
                         Collection *to_parent,
                         Collection *from_parent,
                         Collection *relative,
                         bool relative_after,
                         Collection *collection);

bool BKE_collection_cycle_find(Collection *new_ancestor, Collection *collection);
bool BKE_collection_cycles_fix(Main *bmain, Collection *collection);
 
bool BKE_collection_has_collection(const Collection *parent, const Collection *collection);

Collection *BKE_collection_parent_editable_find_recursive(const ViewLayer *view_layer,
                                                          Collection *collection);
void BKE_collection_parent_relations_rebuild(Collection *collection);
void BKE_main_collections_parent_relations_rebuild(Main *bmain);

bool BKE_collection_validate(Collection *collection);
 
/* .blend file I/O */

void BKE_collection_blend_write_prepare_nolib(BlendWriter *writer, Collection *collection);
void BKE_collection_blend_write_nolib(BlendWriter *writer, Collection *collection);
void BKE_collection_blend_read_data(BlendDataReader *reader, Collection *collection, ID *owner_id);
 
/* Iteration callbacks. */
 
using BKE_scene_objects_Cb = void (*)(Object *ob, void *data);
using BKE_scene_collections_Cb = void (*)(Collection *ob, void *data);
 
/* Iteration over objects in collection. */
 
#define FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_BEGIN(_collection, _object, _mode) \
  { \
    int _base_flag = (_mode == DAG_EVAL_VIEWPORT) ? BASE_ENABLED_VIEWPORT : BASE_ENABLED_RENDER; \
    int _object_visibility_flag = (_mode == DAG_EVAL_VIEWPORT) ? OB_HIDE_VIEWPORT : \
                                                                 OB_HIDE_RENDER; \
    int _base_id = 0; \
    for (Base *_base = static_cast<Base *>(BKE_collection_object_cache_get(_collection).first); \
         _base; \
         _base = _base->next, _base_id++) \
    { \
      Object *_object = _base->object; \
      if ((_base->flag & _base_flag) && \
          (_object->visibility_flag & _object_visibility_flag) == 0) {
 
#define FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_END \
  } \
  } \
  } \
  ((void)0)
 
#define FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN(_collection, _object) \
  for (Base *_base = static_cast<Base *>(BKE_collection_object_cache_get(_collection).first); \
       _base; \
       _base = _base->next) \
  { \
    Object *_object = _base->object; \
    BLI_assert(_object != NULL);
 
#define FOREACH_COLLECTION_OBJECT_RECURSIVE_END \
  } \
  ((void)0)
 
/* Iteration over collections in scene. */

void BKE_scene_collections_iterator_begin(BLI_Iterator *iter, void *data_in);
void BKE_scene_collections_iterator_next(BLI_Iterator *iter);
void BKE_scene_collections_iterator_end(BLI_Iterator *iter);
 
void BKE_scene_objects_iterator_begin(BLI_Iterator *iter, void *data_in);
void BKE_scene_objects_iterator_next(BLI_Iterator *iter);
void BKE_scene_objects_iterator_end(BLI_Iterator *iter);

struct SceneObjectsIteratorExData {
  Scene *scene;
  int flag;
  void *iter_data;
};
 
void BKE_scene_objects_iterator_begin_ex(BLI_Iterator *iter, void *data_in);
void BKE_scene_objects_iterator_next_ex(BLI_Iterator *iter);
void BKE_scene_objects_iterator_end_ex(BLI_Iterator *iter);

GSet *BKE_scene_objects_as_gset(Scene *scene, GSet *objects_gset);
 
#define FOREACH_SCENE_COLLECTION_BEGIN(scene, _instance) \
  ITER_BEGIN (BKE_scene_collections_iterator_begin, \
              BKE_scene_collections_iterator_next, \
              BKE_scene_collections_iterator_end, \
              scene, \
              Collection *, \
              _instance)
 
#define FOREACH_SCENE_COLLECTION_END ITER_END
 
#define FOREACH_COLLECTION_BEGIN(_bmain, _scene, Type, _instance) \
  { \
    Type _instance; \
    Collection *_instance_next; \
    bool is_scene_collection = (_scene) != NULL; \
\
    if (_scene) { \
      _instance_next = (_scene)->master_collection; \
    } \
    else { \
      _instance_next = static_cast<Collection *>((_bmain)->collections.first); \
    } \
\
    while ((_instance = _instance_next)) { \
      if (is_scene_collection) { \
        _instance_next = static_cast<Collection *>((_bmain)->collections.first); \
        is_scene_collection = false; \
      } \
      else { \
        _instance_next = static_cast<Collection *>(_instance->id.next); \
      }
 
#define FOREACH_COLLECTION_END \
  } \
  } \
  ((void)0)
 
#define FOREACH_SCENE_OBJECT_BEGIN(scene, _instance) \
  ITER_BEGIN (BKE_scene_objects_iterator_begin, \
              BKE_scene_objects_iterator_next, \
              BKE_scene_objects_iterator_end, \
              scene, \
              Object *, \
              _instance)
 
#define FOREACH_SCENE_OBJECT_END ITER_END