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_math_matrix_types.hh"
#include "BLI_sys_types.h"
#include "BLI_utility_mixins.hh"
#include "BLI_vector_set.hh"
 
#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 MainColorspace {
  /*
   * File working colorspace for all scene linear colors.
   * The name is only for the user interface and is not a unique identifier, the matrix is
   * the XYZ colorspace is the source of truth.
   * */
  char scene_linear_name[64 /*MAX_COLORSPACE_NAME*/] = "";
  blender::float3x3 scene_linear_to_xyz = blender::float3x3::zero();
 
  /*
   * A colorspace, view or display was not found, which likely means the OpenColorIO config
   * used to create this blend file is missing.
   */
  bool is_missing_opencolorio_config = false;
};
 
struct Main : blender::NonCopyable, blender::NonMovable {
  std::shared_ptr<blender::VectorSet<Main *>> split_mains = {};
  char filepath[/*FILE_MAX*/ 1024] = "";
  /* See BLENDER_FILE_VERSION, BLENDER_FILE_SUBVERSION. */
  short versionfile = 0;
  short subversionfile = 0;
  /* See BLENDER_FILE_MIN_VERSION, BLENDER_FILE_MIN_SUBVERSION. */
  short minversionfile = 0;
  short minsubversionfile = 0;
  bool has_forward_compatibility_issues = false;

  bool is_asset_edit_file = false;

  uint64_t build_commit_timestamp = 0;
  char build_hash[16] = {};
  bool recovered = false;
  bool is_memfile_undo_written = false;
  bool is_memfile_undo_flush_needed = false;
  bool use_memfile_full_barrier = false;

  bool is_locked_for_linking = false;

  bool is_read_invalid = false;

  bool is_global_main = false;

  bool is_action_slot_to_id_map_dirty = false;

  BlendThumbnail *blen_thumb = nullptr;

  Library *curlib = nullptr;
 
  /*
   * Colorspace information for this file.
   */
  MainColorspace colorspace;
 
  /* 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 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 = nullptr;

  IDNameLib_Map *id_map = nullptr;

  UniqueName_Map *name_map = nullptr;

  UniqueName_Map *name_map_global = nullptr;
 
  MainLock *lock = nullptr;
 
  /* Constructors and destructors. */
  Main();
  ~Main();
};

Main *BKE_main_new();
void BKE_main_clear(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();
const char *BKE_main_blendfile_path_from_library(const Library &library);

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)))
 
/* NOTE: in case versionfile is 0, this check is invalid, always return false then. This happens
 * typically when a library is missing, by definition its data (placeholder IDs) does not need
 * versionning anyway then. */
#define LIBRARY_VERSION_FILE_ATLEAST(lib, ver, subver) \
  ((lib)->runtime->versionfile == 0 || (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))))