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 <array>
 
#include "DNA_listBase.h"
 
#include "BLI_compiler_attrs.h"
#include "BLI_sys_types.h"
 
#include "BKE_lib_query.hh" /* For LibraryForeachIDCallbackFlag. */
 
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 {
    ID *from;
    ID **to;
  } id_pointer;
  uint session_uid;

  LibraryForeachIDCallbackFlag usage_flag;
};
 
struct MainIDRelationsEntry {
  MainIDRelationsEntryItem *from_ids;
  MainIDRelationsEntryItem *to_ids;

  uint session_uid;

  uint tags;
};

enum eMainIDRelationsEntryTags {
  MAINIDRELATIONS_ENTRY_TAGS_DOIT = 1 << 0,

  MAINIDRELATIONS_ENTRY_TAGS_PROCESSED_TO = 1 << 4,
  MAINIDRELATIONS_ENTRY_TAGS_PROCESSED_FROM = 1 << 5,
  MAINIDRELATIONS_ENTRY_TAGS_PROCESSED = MAINIDRELATIONS_ENTRY_TAGS_PROCESSED_TO |
                                         MAINIDRELATIONS_ENTRY_TAGS_PROCESSED_FROM,

  MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS_TO = 1 << 8,
  MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS_FROM = 1 << 9,
  MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS = MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS_TO |
                                          MAINIDRELATIONS_ENTRY_TAGS_INPROGRESS_FROM,
};
 
struct MainIDRelations {
  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 {
  MAINIDRELATIONS_INCLUDE_UI = 1 << 0,
};
 
struct Main {
  Main *next, *prev;
  char filepath[/*FILE_MAX*/ 1024];
  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;
 
  /* List bases for all ID types, containing all IDs for the current #Main. */
 
  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;
  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;
  ListBase gpencils;
  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;

  UniqueName_Map *name_map_global;
 
  MainLock *lock;
};

Main *BKE_main_new();
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();

ID *BKE_main_library_weak_reference_find(Main *bmain,
                                         const char *library_filepath,
                                         const char *library_id_name);

void BKE_main_library_weak_reference_add(ID *local_id,
                                         const char *library_filepath,
                                         const char *library_id_name);
 
/* *** 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) \
  { \
    MainListsArray _lbarray = BKE_main_lists_get(*(_bmain)); \
    size_t _i = _lbarray.size(); \
    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);

using MainListsArray = std::array<ListBase *, INDEX_ID_MAX - 1>;

MainListsArray BKE_main_lists_get(Main &bmain);
 
#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))))