BKE_main.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
 
#include "DNA_listBase.h"
 
#include "BLI_compiler_attrs.h"
#include "BLI_sys_types.h"
 
struct BLI_mempool;
struct BlendThumbnail;
struct GHash;
struct GSet;
struct ID;
struct IDNameLib_Map;
struct ImBuf;
struct Library;
struct MainLock;
struct ReportList;
struct UniqueName_Map;
 
struct BlendThumbnail {
  int width, height;
  char rect[0];
};
 
struct MainIDRelationsEntryItem {
  MainIDRelationsEntryItem *next;
 
  union {
    /* For `from_ids` list, a user of the hashed ID. */
    ID *from;
    /* For `to_ids` list, an ID used by the hashed ID. */
    ID **to;
  } id_pointer;
  /* Session uid of the `id_pointer`. */
  uint session_uid;
 
  int usage_flag; /* Using IDWALK_ enums, defined in BKE_lib_query.hh */
};
 
struct MainIDRelationsEntry {
  /* Linked list of IDs using that ID. */
  MainIDRelationsEntryItem *from_ids;
  /* Linked list of IDs used by that ID. */
  MainIDRelationsEntryItem *to_ids;
 
  /* Session uid of the ID matching that entry. */
  uint session_uid;
 
  /* Runtime tags, users should ensure those are reset after usage. */
  uint tags;
};
 
enum eMainIDRelationsEntryTags {
  /* Generic tag marking the entry as to be processed. */
  MAINIDRELATIONS_ENTRY_TAGS_DOIT = 1 << 0,
 
  /* Generic tag marking the entry as processed in the `to` direction (i.e. the IDs used by this
   * item have been processed). */
  MAINIDRELATIONS_ENTRY_TAGS_PROCESSED_TO = 1 << 4,
  /* Generic tag marking the entry as processed in the `from` direction (i.e. the IDs using this
   * item have been processed). */
  MAINIDRELATIONS_ENTRY_TAGS_PROCESSED_FROM = 1 << 5,
  /* Generic tag marking the entry as processed. */
  MAINIDRELATIONS_ENTRY_TAGS_PROCESSED = MAINIDRELATIONS_ENTRY_TAGS_PROCESSED_TO |
                                         MAINIDRELATIONS_ENTRY_TAGS_PROCESSED_FROM,
 
  /* Generic tag marking the entry as being processed in the `to` direction (i.e. the IDs used by
   * this item are being processed). Useful for dependency loops detection and handling. */
  MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS_TO = 1 << 8,
  /* Generic tag marking the entry as being processed in the `from` direction (i.e. the IDs using
   * this item are being processed). Useful for dependency loops detection and handling. */
  MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS_FROM = 1 << 9,
  /* Generic tag marking the entry as being processed. Useful for dependency loops detection and
   * handling. */
  MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS = MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS_TO |
                                          MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS_FROM,
};
 
struct MainIDRelations {
  /* Mapping from an ID pointer to all of its parents (IDs using it) and children (IDs it uses).
   * Values are `MainIDRelationsEntry` pointers. */
  GHash *relations_from_pointers;
  /* NOTE: we could add more mappings when needed (e.g. from session uid?). */
 
  short flag;
 
  /* Private... */
  BLI_mempool *entry_items_pool;
};
 
enum {
  /* Those bmain relations include pointers/usages from editors. */
  MAINIDRELATIONS_INCLUDE_UI = 1 << 0,
};
 
struct Main {
  Main *next, *prev;
  char filepath[1024];               /* 1024 = FILE_MAX */
  short versionfile, subversionfile; /* see BLENDER_FILE_VERSION, BLENDER_FILE_SUBVERSION */
  short minversionfile, minsubversionfile;
  bool has_forward_compatibility_issues;
 
  bool is_asset_edit_file;
 
  uint64_t build_commit_timestamp;
  char build_hash[16];
  bool recovered;
  bool is_memfile_undo_written;
  bool is_memfile_undo_flush_needed;
  bool use_memfile_full_barrier;
 
  bool is_locked_for_linking;
 
  bool is_read_invalid;
 
  bool is_global_main;
 
  bool is_action_slot_to_id_map_dirty;
 
  BlendThumbnail *blen_thumb;
 
  Library *curlib;
  ListBase scenes;
  ListBase libraries;
  ListBase objects;
  ListBase meshes;
  ListBase curves;
  ListBase metaballs;
  ListBase materials;
  ListBase textures;
  ListBase images;
  ListBase lattices;
  ListBase lights;
  ListBase cameras;
  ListBase ipo; /* Deprecated (only for versioning). */
  ListBase shapekeys;
  ListBase worlds;
  ListBase screens;
  ListBase fonts;
  ListBase texts;
  ListBase speakers;
  ListBase lightprobes;
  ListBase sounds;
  ListBase collections;
  ListBase armatures;
  ListBase actions;
  ListBase nodetrees;
  ListBase brushes;
  ListBase particles;
  ListBase palettes;
  ListBase paintcurves;
  ListBase wm;       /* Singleton (exception). */
  ListBase gpencils; /* Legacy Grease Pencil. */
  ListBase grease_pencils;
  ListBase movieclips;
  ListBase masks;
  ListBase linestyles;
  ListBase cachefiles;
  ListBase workspaces;
  ListBase hair_curves;
  ListBase pointclouds;
  ListBase volumes;
 
  MainIDRelations *relations;
 
  IDNameLib_Map *id_map;
 
  UniqueName_Map *name_map;
 
  /* Used for efficient calculations of unique names. Covers all names in current Main, including
   * linked data ones. */
  UniqueName_Map *name_map_global;
 
  MainLock *lock;
};
 
Main *BKE_main_new(void);
void BKE_main_init(Main &bmain);
void BKE_main_clear(Main &bmain);
void BKE_main_destroy(Main &bmain);
void BKE_main_free(Main *bmain);
 
struct MainMergeReport {
  ReportList *reports = nullptr;
 
  int num_merged_ids = 0;
  int num_unknown_ids = 0;
  int num_remapped_ids = 0;
  int num_remapped_libraries = 0;
};
 
void BKE_main_merge(Main *bmain_dst, Main **r_bmain_src, MainMergeReport &reports);
 
bool BKE_main_is_empty(Main *bmain);
 
bool BKE_main_has_issues(const Main *bmain);
 
bool BKE_main_needs_overwrite_confirm(const Main *bmain);
 
void BKE_main_lock(Main *bmain);
void BKE_main_unlock(Main *bmain);
 
void BKE_main_relations_create(Main *bmain, short flag);
void BKE_main_relations_free(Main *bmain);
void BKE_main_relations_tag_set(Main *bmain, eMainIDRelationsEntryTags tag, bool value);
 
GSet *BKE_main_gset_create(Main *bmain, GSet *gset);
 
/* Temporary runtime API to allow re-using local (already appended)
 * IDs instead of appending a new copy again. */
 
struct MainLibraryWeakReferenceMap;
 
MainLibraryWeakReferenceMap *BKE_main_library_weak_reference_create(Main *bmain) ATTR_NONNULL();
void BKE_main_library_weak_reference_destroy(
    MainLibraryWeakReferenceMap *library_weak_reference_mapping) ATTR_NONNULL();
ID *BKE_main_library_weak_reference_search_item(
    MainLibraryWeakReferenceMap *library_weak_reference_mapping,
    const char *library_filepath,
    const char *library_id_name) ATTR_NONNULL();
void BKE_main_library_weak_reference_add_item(
    MainLibraryWeakReferenceMap *library_weak_reference_mapping,
    const char *library_filepath,
    const char *library_id_name,
    ID *new_id) ATTR_NONNULL();
void BKE_main_library_weak_reference_update_item(
    MainLibraryWeakReferenceMap *library_weak_reference_mapping,
    const char *library_filepath,
    const char *library_id_name,
    ID *old_id,
    ID *new_id) ATTR_NONNULL();
void BKE_main_library_weak_reference_remove_item(
    MainLibraryWeakReferenceMap *library_weak_reference_mapping,
    const char *library_filepath,
    const char *library_id_name,
    ID *old_id) ATTR_NONNULL();
 
/* *** Generic utils to loop over whole Main database. *** */
 
#define FOREACH_MAIN_LISTBASE_ID_BEGIN(_lb, _id) \
  { \
    ID *_id_next = static_cast<ID *>((_lb)->first); \
    for ((_id) = _id_next; (_id) != nullptr; (_id) = _id_next) { \
      _id_next = static_cast<ID *>((_id)->next);
 
#define FOREACH_MAIN_LISTBASE_ID_END \
  } \
  } \
  ((void)0)
 
#define FOREACH_MAIN_LISTBASE_BEGIN(_bmain, _lb) \
  { \
    ListBase *_lbarray[INDEX_ID_MAX]; \
    int _i = set_listbasepointers((_bmain), _lbarray); \
    while (_i--) { \
      (_lb) = _lbarray[_i];
 
#define FOREACH_MAIN_LISTBASE_END \
  } \
  } \
  ((void)0)
 
#define FOREACH_MAIN_ID_BEGIN(_bmain, _id) \
  { \
    ListBase *_lb; \
    FOREACH_MAIN_LISTBASE_BEGIN ((_bmain), _lb) { \
      FOREACH_MAIN_LISTBASE_ID_BEGIN (_lb, (_id))
 
#define FOREACH_MAIN_ID_END \
  FOREACH_MAIN_LISTBASE_ID_END; \
  } \
  FOREACH_MAIN_LISTBASE_END; \
  } \
  ((void)0)
 
BlendThumbnail *BKE_main_thumbnail_from_buffer(Main *bmain,
                                               const uint8_t *rect,
                                               const int size[2]);
 
BlendThumbnail *BKE_main_thumbnail_from_imbuf(Main *bmain, ImBuf *img);
ImBuf *BKE_main_thumbnail_to_imbuf(Main *bmain, BlendThumbnail *data);
void BKE_main_thumbnail_create(Main *bmain);
 
const char *BKE_main_blendfile_path(const Main *bmain) ATTR_NONNULL();
const char *BKE_main_blendfile_path_from_global();
 
ListBase *which_libbase(Main *bmain, short type);
 
// #define INDEX_ID_MAX 41
int set_listbasepointers(Main *bmain, ListBase *lb[]);
 
#define MAIN_VERSION_FILE_ATLEAST(main, ver, subver) \
  ((main)->versionfile > (ver) || \
   ((main)->versionfile == (ver) && (main)->subversionfile >= (subver)))
 
#define MAIN_VERSION_FILE_OLDER(main, ver, subver) \
  ((main)->versionfile < (ver) || \
   ((main)->versionfile == (ver) && (main)->subversionfile < (subver)))
 
#define MAIN_VERSION_FILE_OLDER_OR_EQUAL(main, ver, subver) \
  ((main)->versionfile < (ver) || \
   ((main)->versionfile == (ver) && (main)->subversionfile <= (subver)))
 
#define LIBRARY_VERSION_FILE_ATLEAST(lib, ver, subver) \
  ((lib)->runtime.versionfile > (ver) || \
   ((lib)->runtime.versionfile == (ver) && (lib)->runtime.subversionfile >= (subver)))
 
#define BLEN_THUMB_SIZE 128
 
#define BLEN_THUMB_MEMSIZE(_x, _y) \
  (sizeof(BlendThumbnail) + ((size_t)(_x) * (size_t)(_y)) * sizeof(int))
#define BLEN_THUMB_MEMSIZE_IS_VALID(_x, _y) \
  (((_x) > 0 && (_y) > 0) && ((uint64_t)(_x) * (uint64_t)(_y) < (SIZE_MAX / (sizeof(int) * 4))))