DNA_ID.h

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_ID_enums.h"
#include "DNA_defs.h"
#include "DNA_listBase.h"
 
#ifdef __cplusplus
namespace blender::bke {
struct PreviewImageRuntime;
}
using PreviewImageRuntimeHandle = blender::bke::PreviewImageRuntime;
#else
typedef struct PreviewImageRuntimeHandle PreviewImageRuntimeHandle;
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct FileData;
struct GHash;
struct ID;
struct Library;
struct PackedFile;
struct UniqueName_Map;
struct Depsgraph;
 
/* Runtime display data */
struct DrawData;
typedef void (*DrawDataInitCb)(struct DrawData *engine_data);
typedef void (*DrawDataFreeCb)(struct DrawData *engine_data);
 
#
#
typedef struct DrawData {
  struct DrawData *next, *prev;
  struct DrawEngineType *engine_type;
  /* Only nested data, NOT the engine data itself. */
  DrawDataFreeCb free;
  /* Accumulated recalc flags, which corresponds to ID->recalc flags. */
  unsigned int recalc;
} DrawData;
 
typedef struct DrawDataList {
  struct DrawData *first, *last;
} DrawDataList;
 
typedef struct IDPropertyUIData {
  char *description;
  int rna_subtype;
 
  char _pad[4];
} IDPropertyUIData;
 
/* DNA version of #EnumPropertyItem. */
typedef struct IDPropertyUIDataEnumItem {
  /* Unique identifier, used for string lookup. */
  char *identifier;
  /* UI name of the item. */
  char *name;
  /* Optional description. */
  char *description;
  /* Unique integer value, should never change. */
  int value;
  /* Optional icon. */
  int icon;
} IDPropertyUIDataEnumItem;
 
/* IDP_UI_DATA_TYPE_INT */
typedef struct IDPropertyUIDataInt {
  IDPropertyUIData base;
  int *default_array; /* Only for array properties. */
  int default_array_len;
 
  int min;
  int max;
  int soft_min;
  int soft_max;
  int step;
  int default_value;
 
  int enum_items_num;
  IDPropertyUIDataEnumItem *enum_items;
} IDPropertyUIDataInt;
 
typedef struct IDPropertyUIDataBool {
  IDPropertyUIData base;
  int8_t *default_array; /* Only for array properties. */
  int default_array_len;
  char _pad[3];
 
  int8_t default_value;
} IDPropertyUIDataBool;
 
typedef struct IDPropertyUIDataFloat {
  IDPropertyUIData base;
  double *default_array; /* Only for array properties. */
  int default_array_len;
  char _pad[4];
 
  float step;
  int precision;
 
  double min;
  double max;
  double soft_min;
  double soft_max;
  double default_value;
} IDPropertyUIDataFloat;
 
typedef struct IDPropertyUIDataString {
  IDPropertyUIData base;
  char *default_value;
} IDPropertyUIDataString;
 
typedef struct IDPropertyUIDataID {
  IDPropertyUIData base;
  short id_type;
  char _pad[6];
} IDPropertyUIDataID;
 
typedef struct IDPropertyData {
  void *pointer;
  ListBase group;
  int val, val2;
} IDPropertyData;
 
typedef struct IDProperty {
  struct IDProperty *next, *prev;
  char type;
  char subtype;
  short flag;
  char name[64];
 
  char _pad0[4];
 
  IDPropertyData data;
 
  int len;
  int totallen;
 
  IDPropertyUIData *ui_data;
} IDProperty;
 
#define MAX_IDPROP_NAME 64
#define DEFAULT_ALLOC_FOR_NULL_STRINGS 64
 
/* add any future new id property types here. */
 
/* Static ID override structs. */
 
typedef struct IDOverrideLibraryPropertyOperation {
  struct IDOverrideLibraryPropertyOperation *next, *prev;
 
  /* Type of override. */
  short operation;
  short flag;
 
  short tag;
  char _pad0[2];
 
  /* Sub-item references, if needed (for arrays or collections only).
   * We need both reference and local values to allow e.g. insertion into RNA collections
   * (constraints, modifiers...).
   * In RNA collection case, if names are defined, they are used in priority.
   * Names are pointers (instead of char[64]) to save some space, NULL or empty string when unset.
   * Indices are -1 when unset.
   *
   * NOTE: For insertion operations in RNA collections, reference may not actually exist in the
   * linked reference data. It is used to identify the anchor of the insertion operation (i.e. the
   * item after or before which the new local item should be inserted), in the local override. */
  char *subitem_reference_name;
  char *subitem_local_name;
  int subitem_reference_index;
  int subitem_local_index;
  struct ID *subitem_reference_id;
  struct ID *subitem_local_id;
} IDOverrideLibraryPropertyOperation;
 
/* IDOverrideLibraryPropertyOperation->operation. */
enum {
  /* Basic operations. */
  LIBOVERRIDE_OP_NOOP = 0, /* Special value, forbids any overriding. */
 
  LIBOVERRIDE_OP_REPLACE = 1, /* Fully replace local value by reference one. */
 
  /* Numeric-only operations. */
  LIBOVERRIDE_OP_ADD = 101, /* Add local value to reference one. */
  /* Subtract local value from reference one (needed due to unsigned values etc.). */
  LIBOVERRIDE_OP_SUBTRACT = 102,
  /* Multiply reference value by local one (more useful than diff for scales and the like). */
  LIBOVERRIDE_OP_MULTIPLY = 103,
 
  /* Collection-only operations. */
  LIBOVERRIDE_OP_INSERT_AFTER = 201,  /* Insert after given reference's subitem. */
  LIBOVERRIDE_OP_INSERT_BEFORE = 202, /* Insert before given reference's subitem. */
  /* We can add more if needed (move, delete, ...). */
};
 
/* IDOverrideLibraryPropertyOperation->flag. */
enum {
  LIBOVERRIDE_OP_FLAG_MANDATORY = 1 << 0,
  LIBOVERRIDE_OP_FLAG_LOCKED = 1 << 1,
 
  LIBOVERRIDE_OP_FLAG_IDPOINTER_MATCH_REFERENCE = 1 << 8,
  LIBOVERRIDE_OP_FLAG_IDPOINTER_ITEM_USE_ID = 1 << 9,
};
 
typedef struct IDOverrideLibraryProperty {
  struct IDOverrideLibraryProperty *next, *prev;
 
  char *rna_path;
 
  ListBase operations;
 
  short tag;
  char _pad[2];
 
  unsigned int rna_prop_type;
} IDOverrideLibraryProperty;
 
/* IDOverrideLibraryProperty->tag and IDOverrideLibraryPropertyOperation->tag. */
enum {
  LIBOVERRIDE_PROP_OP_TAG_UNUSED = 1 << 0,
 
  LIBOVERRIDE_PROP_TAG_NEEDS_RETORE = 1 << 1,
};
 
#
#
typedef struct IDOverrideLibraryRuntime {
  struct GHash *rna_path_to_override_properties;
  uint tag;
} IDOverrideLibraryRuntime;
 
/* IDOverrideLibraryRuntime->tag. */
enum {
  LIBOVERRIDE_TAG_NEEDS_RELOAD = 1 << 0,
 
  LIBOVERRIDE_TAG_NEEDS_RESTORE = 1 << 1,
 
  LIBOVERRIDE_TAG_RESYNC_ISOLATED_FROM_ROOT = 1 << 2,
  LIBOVERRIDE_TAG_NEED_RESYNC_ORIGINAL = 1 << 3,
};
 
/* Main container for all overriding data info of a data-block. */
typedef struct IDOverrideLibrary {
  struct ID *reference;
  ListBase properties;
 
  struct ID *hierarchy_root;
 
  /* Read/write data. */
  /* Temp ID storing extra override data (used for differential operations only currently).
   * Always NULL outside of read/write context. */
  struct ID *storage;
 
  IDOverrideLibraryRuntime *runtime;
 
  unsigned int flag;
  char _pad_1[4];
} IDOverrideLibrary;
 
/* IDOverrideLibrary->flag */
enum {
  LIBOVERRIDE_FLAG_NO_HIERARCHY = 1 << 0,
  LIBOVERRIDE_FLAG_SYSTEM_DEFINED = 1 << 1,
};
 
/* watch it: Sequence has identical beginning. */
/* 2 characters for ID code and 64 for actual name */
#define MAX_ID_NAME 66
 
enum {
  ID_REMAP_IS_LINKED_DIRECT = 1 << 0,
  ID_REMAP_IS_USER_ONE_SKIPPED = 1 << 1,
};
 
typedef struct ID_Runtime_Remap {
  int status;
  int skipped_refcounted;
  int skipped_direct;
  int skipped_indirect;
} ID_Runtime_Remap;
 
typedef struct ID_Runtime {
  ID_Runtime_Remap remap;
  struct Depsgraph *depsgraph;
  void *_pad;
} ID_Runtime;
 
typedef struct ID {
  /* There's a nasty circular dependency here.... 'void *' to the rescue! I
   * really wonder why this is needed. */
  void *next, *prev;
  struct ID *newid;
 
  struct Library *lib;
 
  struct AssetMetaData *asset_data;
 
  char name[66];
  short flag;
  int tag;
  int us;
  int icon_id;
  unsigned int recalc;
  unsigned int recalc_up_to_undo_push;
  unsigned int recalc_after_undo_push;
 
  unsigned int session_uid;
 
  IDProperty *properties;
 
  IDOverrideLibrary *override_library;
 
  struct ID *orig_id;
 
  void *py_instance;
 
  struct LibraryWeakReference *library_weak_reference;
 
  struct ID_Runtime runtime;
} ID;
 
typedef struct Library_Runtime {
  /* Used for efficient calculations of unique names. */
  struct UniqueName_Map *name_map;
 
  struct FileData *filedata;
 
  char filepath_abs[1024];
 
  struct Library *parent;
 
  ushort tag;
  char _pad[6];
 
  int temp_index;
 
  short versionfile, subversionfile;
} Library_Runtime;
 
typedef struct Library {
  ID id;
  char filepath[1024];
 
  struct PackedFile *packedfile;
 
  struct Library_Runtime runtime;
} Library;
 
enum eLibrary_Tag {
  LIBRARY_TAG_RESYNC_REQUIRED = 1 << 0,
  LIBRARY_ASSET_EDITABLE = 1 << 1,
  LIBRARY_ASSET_FILE_WRITABLE = 1 << 2,
  LIBRARY_IS_ASSET_EDIT_FILE = 1 << 3,
};
 
typedef struct LibraryWeakReference {
  char library_filepath[1024];
 
  char library_id_name[66];
 
  char _pad[2];
} LibraryWeakReference;
 
/* PreviewImage.flag */
enum ePreviewImage_Flag {
  PRV_CHANGED = (1 << 0),
  PRV_USER_EDITED = (1 << 1),
  /* Rendering was invoked. Cleared on file read. */
  PRV_RENDERING = (1 << 2),
};
 
/* PreviewImage.tag */
enum {
  PRV_TAG_DEFFERED_RENDERING = (1 << 1),
  PRV_TAG_DEFFERED_DELETE = (1 << 2),
};
 
typedef struct PreviewImage {
  DNA_DEFINE_CXX_METHODS(PreviewImage)
  /* All values of 2 are really NUM_ICON_SIZES */
  unsigned int w[2];
  unsigned int h[2];
  short flag[2];
  short changed_timestamp[2];
  unsigned int *rect[2];
 
  PreviewImageRuntimeHandle *runtime;
} PreviewImage;
 
#define ID_FAKE_USERS(id) ((((const ID *)id)->flag & ID_FLAG_FAKEUSER) ? 1 : 0)
#define ID_EXTRA_USERS(id) (((const ID *)id)->tag & ID_TAG_EXTRAUSER ? 1 : 0)
#define ID_EXTRA_REAL_USERS(id) (((const ID *)id)->tag & ID_TAG_EXTRAUSER_SET ? 1 : 0)
#define ID_REAL_USERS(id) (((const ID *)id)->us - ID_FAKE_USERS(id))
#define ID_REFCOUNTING_USERS(id) (ID_REAL_USERS(id) - ID_EXTRA_REAL_USERS(id))
 
#define ID_CHECK_UNDO(id) \
  ((GS((id)->name) != ID_SCR) && (GS((id)->name) != ID_WM) && (GS((id)->name) != ID_WS))
 
#define ID_BLEND_PATH(_bmain, _id) \
  ((_id)->lib ? (_id)->lib->runtime.filepath_abs : BKE_main_blendfile_path((_bmain)))
#define ID_BLEND_PATH_FROM_GLOBAL(_id) \
  ((_id)->lib ? (_id)->lib->runtime.filepath_abs : BKE_main_blendfile_path_from_global())
 
#define ID_MISSING(_id) ((((const ID *)(_id))->tag & ID_TAG_MISSING) != 0)
 
#define ID_IS_LINKED(_id) (((const ID *)(_id))->lib != NULL)
 
#define ID_TYPE_SUPPORTS_ASSET_EDITABLE(id_type) ELEM(id_type, ID_BR, ID_TE, ID_NT, ID_IM, ID_PC)
 
#define ID_IS_EDITABLE(_id) \
  ((((const ID *)(_id))->lib == NULL) || \
   ((((const ID *)(_id))->lib->runtime.tag & LIBRARY_ASSET_EDITABLE) && \
    ID_TYPE_SUPPORTS_ASSET_EDITABLE(GS((((const ID *)(_id))->name)))))
 
/* Note that these are fairly high-level checks, should be used at user interaction level, not in
 * BKE_library_override typically (especially due to the check on ID_TAG_EXTERN). */
#define ID_IS_OVERRIDABLE_LIBRARY_HIERARCHY(_id) \
  (ID_IS_LINKED(_id) && !ID_MISSING(_id) && \
   (BKE_idtype_get_info_from_id((const ID *)(_id))->flags & IDTYPE_FLAGS_NO_LIBLINKING) == 0 && \
   !ELEM(GS(((ID *)(_id))->name), ID_SCE))
#define ID_IS_OVERRIDABLE_LIBRARY(_id) \
  (ID_IS_OVERRIDABLE_LIBRARY_HIERARCHY((_id)) && (((const ID *)(_id))->tag & ID_TAG_EXTERN) != 0)
 
/* NOTE: The three checks below do not take into account whether given ID is linked or not (when
 * chaining overrides over several libraries). User must ensure the ID is not linked itself
 * currently. */
/* TODO: add `_EDITABLE` versions of those macros (that would check if ID is linked or not)? */
#define ID_IS_OVERRIDE_LIBRARY_REAL(_id) \
  (((const ID *)(_id))->override_library != NULL && \
   ((const ID *)(_id))->override_library->reference != NULL)
 
#define ID_IS_OVERRIDE_LIBRARY_VIRTUAL(_id) \
  ((((const ID *)(_id))->flag & ID_FLAG_EMBEDDED_DATA_LIB_OVERRIDE) != 0)
 
#define ID_IS_OVERRIDE_LIBRARY(_id) \
  (ID_IS_OVERRIDE_LIBRARY_REAL(_id) || ID_IS_OVERRIDE_LIBRARY_VIRTUAL(_id))
 
#define ID_IS_OVERRIDE_LIBRARY_HIERARCHY_ROOT(_id) \
  (!ID_IS_OVERRIDE_LIBRARY_REAL(_id) || \
   ((ID *)(_id))->override_library->hierarchy_root == ((ID *)(_id)))
 
#define ID_IS_ASSET(_id) (((const ID *)(_id))->asset_data != NULL)
 
/* Check whether datablock type is covered by copy-on-evaluation. */
#define ID_TYPE_USE_COPY_ON_EVAL(_id_type) \
  (!ELEM(_id_type, ID_LI, ID_IP, ID_SCR, ID_VF, ID_BR, ID_WM, ID_PAL, ID_PC, ID_WS, ID_IM))
 
/* Check whether data-block type requires copy-on-evaluation from #ID_RECALC_PARAMETERS.
 * Keep in sync with #BKE_id_eval_properties_copy. */
#define ID_TYPE_SUPPORTS_PARAMS_WITHOUT_COW(id_type) ELEM(id_type, ID_ME)
 
#define ID_TYPE_IS_DEPRECATED(id_type) ELEM(id_type, ID_IP)
 
#ifdef GS
#  undef GS
#endif
#define GS(a) (CHECK_TYPE_ANY(a, char *, const char *), (ID_Type)(*((const short *)(a))))
 
#define ID_NEW_SET(_id, _idn) \
  (((ID *)(_id))->newid = (ID *)(_idn), \
   ((ID *)(_id))->newid->tag |= ID_TAG_NEW, \
   (void *)((ID *)(_id))->newid)
#define ID_NEW_REMAP(a) \
  if ((a) && (a)->id.newid) { \
    *(void **)&(a) = (a)->id.newid; \
  } \
  ((void)0)
 
enum {
  ID_FLAG_FAKEUSER = 1 << 9,
  ID_FLAG_EMBEDDED_DATA = 1 << 10,
  ID_FLAG_INDIRECT_WEAK_LINK = 1 << 11,
  ID_FLAG_EMBEDDED_DATA_LIB_OVERRIDE = 1 << 12,
  ID_FLAG_LIB_OVERRIDE_RESYNC_LEFTOVER = 1 << 13,
  ID_FLAG_CLIPBOARD_MARK = 1 << 14,
};
 
enum {
  ID_TAG_LOCAL = 0,
  ID_TAG_EXTERN = 1 << 0,
  ID_TAG_INDIRECT = 1 << 1,
 
  ID_TAG_RUNTIME = 1 << 2,
 
  ID_TAG_MISSING = 1 << 3,
 
  ID_TAG_EXTRAUSER = 1 << 4,
  ID_TAG_EXTRAUSER_SET = 1 << 5,
 
  ID_TAG_LIBOVERRIDE_REFOK = 1 << 6,
  ID_TAG_LIBOVERRIDE_AUTOREFRESH = 1 << 7,
  ID_TAG_LIBOVERRIDE_NEED_RESYNC = 1 << 8,
 
  ID_TAG_NEW = 1 << 12,
  ID_TAG_PRE_EXISTING = 1 << 13,
 
  ID_TAG_NEED_EXPAND = 1 << 14,
  ID_TAG_ID_LINK_PLACEHOLDER = 1 << 15,
  ID_TAG_NEED_LINK = 1 << 16,
  ID_TAG_UNDO_OLD_ID_REUSED_UNCHANGED = 1 << 17,
  ID_TAG_UNDO_OLD_ID_REUSED_NOUNDO = 1 << 18,
  ID_TAG_UNDO_OLD_ID_REREAD_IN_PLACE = 1 << 19,
 
  /* ------------------------------------------------------------------------------------------- */
  ID_TAG_TEMP_MAIN = 1 << 20,
  ID_TAG_NO_MAIN = 1 << 21,
  ID_TAG_LOCALIZED = 1 << 22,
  ID_TAG_COPIED_ON_EVAL = 1 << 23,
  ID_TAG_COPIED_ON_EVAL_FINAL_RESULT = 1 << 24,
 
  ID_TAG_NO_USER_REFCOUNT = 1 << 25,
  ID_TAG_NOT_ALLOCATED = 1 << 26,
 
  /* ------------------------------------------------------------------------------------------- */
 
  ID_TAG_DOIT = 1u << 31,
};
 
#define ID_TAG_KEEP_ON_UNDO (ID_TAG_EXTRAUSER | ID_TAG_MISSING | ID_TAG_RUNTIME)
 
/* Tag given ID for an update in all the dependency graphs. */
typedef enum IDRecalcFlag {
  /***************************************************************************
   * Individual update tags, this is what ID gets tagged for update with. */
 
  /* ** Object transformation changed. ** */
  ID_RECALC_TRANSFORM = (1 << 0),
 
  /* ** Geometry changed. **
   *
   * When object of armature type gets tagged with this flag, its pose is
   * re-evaluated.
   *
   * When object of other type is tagged with this flag it makes the modifier
   * stack to be re-evaluated.
   *
   * When object data type (mesh, curve, ...) gets tagged with this flag it
   * makes all objects which shares this data-block to be updated.
   *
   * Note that the evaluation depends on the object-mode.
   * So edit-mesh data for example only reevaluate with the updated edit-mesh.
   * When geometry in the original ID has been modified #ID_RECALC_GEOMETRY_ALL_MODES
   * must be used instead.
   *
   * When a collection gets tagged with this flag, all objects depending on the geometry and
   * transforms on any of the objects in the collection are updated. */
  ID_RECALC_GEOMETRY = (1 << 1),
 
  /* ** Animation or time changed and animation is to be re-evaluated. ** */
  ID_RECALC_ANIMATION = (1 << 2),
 
  /* ** Particle system changed. ** */
  /* Only do path-cache etc. */
  ID_RECALC_PSYS_REDO = (1 << 3),
  /* Reset everything including point-cache. */
  ID_RECALC_PSYS_RESET = (1 << 4),
  /* Only child settings changed. */
  ID_RECALC_PSYS_CHILD = (1 << 5),
  /* Physics type changed. */
  ID_RECALC_PSYS_PHYS = (1 << 6),
 
  /* ** Material and shading ** */
 
  /* For materials and node trees this means that topology of the shader tree
   * changed, and the shader is to be recompiled.
   * For objects it means that the draw batch cache is to be redone. */
  ID_RECALC_SHADING = (1 << 7),
  /* TODO(sergey): Consider adding an explicit ID_RECALC_SHADING_PARAMETERS
   * which can be used for cases when only socket value changed, to speed up
   * redraw update in that case. */
 
  /* Selection of the ID itself or its components (for example, vertices) did
   * change, and all the drawing data is to be updated. */
  ID_RECALC_SELECT = (1 << 9),
  /* Flags on the base did change, and is to be copied onto all the copies of
   * corresponding objects. */
  ID_RECALC_BASE_FLAGS = (1 << 10),
  ID_RECALC_POINT_CACHE = (1 << 11),
  /* Only inform editors about the change. Is used to force update of editors
   * when data-block which is not a part of dependency graph did change.
   *
   * For example, brush texture did change and the preview is to be
   * re-rendered. */
  ID_RECALC_EDITORS = (1 << 12),
 
  /* ** Update evaluated copy component. **
   *
   * This is most generic tag which should only be used when nothing else matches.
   * It is not to explicitly mixed in with other recalculation flags.
   */
  ID_RECALC_SYNC_TO_EVAL = (1 << 13),
 
  /* Sequences in the sequencer did change.
   * Use this tag with a scene ID which owns the sequences. */
  ID_RECALC_SEQUENCER_STRIPS = (1 << 14),
 
  /* Runs on frame-change (used for seeking audio too). */
  ID_RECALC_FRAME_CHANGE = (1 << 15),
 
  ID_RECALC_AUDIO_FPS = (1 << 16),
  ID_RECALC_AUDIO_VOLUME = (1 << 17),
  ID_RECALC_AUDIO_MUTE = (1 << 18),
  ID_RECALC_AUDIO_LISTENER = (1 << 19),
 
  ID_RECALC_AUDIO = (1 << 20),
 
  /* NOTE: This triggers copy-on-eval for types that require it.
   * Exceptions to this can be added using #ID_TYPE_SUPPORTS_PARAMS_WITHOUT_COW,
   * this has the advantage that large arrays stored in the idea data don't
   * have to be copied on every update. */
  ID_RECALC_PARAMETERS = (1 << 21),
 
  /* Input has changed and data-block is to be reload from disk.
   * Applies to movie clips to inform that copy-on-written version is to be refreshed for the new
   * input file or for color space changes. */
  ID_RECALC_SOURCE = (1 << 23),
 
  /* Virtual recalc tag/marker required for undo in some cases, where actual data does not change
   * and hence do not require an update, but conceptually we are dealing with something new.
   *
   * Current known case: linked IDs made local without requiring any copy. While their users do not
   * require any update, they have actually been 'virtually' remapped from the linked ID to the
   * local one.
   */
  ID_RECALC_TAG_FOR_UNDO = (1 << 24),
 
  /* The node tree has changed in a way that affects its output nodes. */
  ID_RECALC_NTREE_OUTPUT = (1 << 25),
 
  /* Hierarchy of collection and object within collection changed. */
  ID_RECALC_HIERARCHY = (1 << 26),
 
  /* Provisioned flags.
   *
   * Not for actual use. The idea of them is to have all bits of the `IDRecalcFlag` defined to a
   * known value, silencing sanitizer warnings when checking bits of the ID_RECALC_ALL. */
  ID_RECALC_PROVISION_27 = (1 << 27),
  ID_RECALC_PROVISION_28 = (1 << 28),
  ID_RECALC_PROVISION_29 = (1 << 29),
  ID_RECALC_PROVISION_30 = (1 << 30),
  ID_RECALC_PROVISION_31 = (1u << 31),
 
  /***************************************************************************
   * Pseudonyms, to have more semantic meaning in the actual code without
   * using too much low-level and implementation specific tags. */
 
  /* Update animation data-block itself, without doing full re-evaluation of
   * all dependent objects. */
  ID_RECALC_ANIMATION_NO_FLUSH = ID_RECALC_SYNC_TO_EVAL,
 
  /* Ensure geometry of object and edit modes are both up-to-date in the evaluated data-block.
   * Example usage is when mesh validation modifies the non-edit-mode data,
   * which we want to be copied over to the evaluated data-block. */
  ID_RECALC_GEOMETRY_ALL_MODES = ID_RECALC_GEOMETRY | ID_RECALC_SYNC_TO_EVAL,
 
  /***************************************************************************
   * Aggregate flags, use only for checks on runtime.
   * Do NOT use those for tagging. */
 
  /* Identifies that SOMETHING has been changed in this ID. */
  ID_RECALC_ALL = (0xffffffff),
 
  /* Identifies that something in particle system did change. */
  ID_RECALC_PSYS_ALL = (ID_RECALC_PSYS_REDO | ID_RECALC_PSYS_RESET | ID_RECALC_PSYS_CHILD |
                        ID_RECALC_PSYS_PHYS),
 
} IDRecalcFlag;
 
/* To filter ID types (filter_id). 64 bit to fit all types. */
#define FILTER_ID_AC (1ULL << 0)
#define FILTER_ID_AR (1ULL << 1)
#define FILTER_ID_BR (1ULL << 2)
#define FILTER_ID_CA (1ULL << 3)
#define FILTER_ID_CU_LEGACY (1ULL << 4)
#define FILTER_ID_GD_LEGACY (1ULL << 5)
#define FILTER_ID_GR (1ULL << 6)
#define FILTER_ID_IM (1ULL << 7)
#define FILTER_ID_LA (1ULL << 8)
#define FILTER_ID_LS (1ULL << 9)
#define FILTER_ID_LT (1ULL << 10)
#define FILTER_ID_MA (1ULL << 11)
#define FILTER_ID_MB (1ULL << 12)
#define FILTER_ID_MC (1ULL << 13)
#define FILTER_ID_ME (1ULL << 14)
#define FILTER_ID_MSK (1ULL << 15)
#define FILTER_ID_NT (1ULL << 16)
#define FILTER_ID_OB (1ULL << 17)
#define FILTER_ID_PAL (1ULL << 18)
#define FILTER_ID_PC (1ULL << 19)
#define FILTER_ID_SCE (1ULL << 20)
#define FILTER_ID_SPK (1ULL << 21)
#define FILTER_ID_SO (1ULL << 22)
#define FILTER_ID_TE (1ULL << 23)
#define FILTER_ID_TXT (1ULL << 24)
#define FILTER_ID_VF (1ULL << 25)
#define FILTER_ID_WO (1ULL << 26)
#define FILTER_ID_PA (1ULL << 27)
#define FILTER_ID_CF (1ULL << 28)
#define FILTER_ID_WS (1ULL << 29)
#define FILTER_ID_LP (1ULL << 31)
#define FILTER_ID_CV (1ULL << 32)
#define FILTER_ID_PT (1ULL << 33)
#define FILTER_ID_VO (1ULL << 34)
#define FILTER_ID_SIM (1ULL << 35)
#define FILTER_ID_KE (1ULL << 36)
#define FILTER_ID_SCR (1ULL << 37)
#define FILTER_ID_WM (1ULL << 38)
#define FILTER_ID_LI (1ULL << 39)
#define FILTER_ID_GP (1ULL << 40)
#define FILTER_ID_IP (1ULL << 41)
 
#define FILTER_ID_ALL \
  (FILTER_ID_AC | FILTER_ID_AR | FILTER_ID_BR | FILTER_ID_CA | FILTER_ID_CU_LEGACY | \
   FILTER_ID_GD_LEGACY | FILTER_ID_GR | FILTER_ID_IM | FILTER_ID_LA | FILTER_ID_LS | \
   FILTER_ID_LT | FILTER_ID_MA | FILTER_ID_MB | FILTER_ID_MC | FILTER_ID_ME | FILTER_ID_MSK | \
   FILTER_ID_NT | FILTER_ID_OB | FILTER_ID_PA | FILTER_ID_PAL | FILTER_ID_PC | FILTER_ID_SCE | \
   FILTER_ID_SPK | FILTER_ID_SO | FILTER_ID_TE | FILTER_ID_TXT | FILTER_ID_VF | FILTER_ID_WO | \
   FILTER_ID_CF | FILTER_ID_WS | FILTER_ID_LP | FILTER_ID_CV | FILTER_ID_PT | FILTER_ID_VO | \
   FILTER_ID_SIM | FILTER_ID_KE | FILTER_ID_SCR | FILTER_ID_WM | FILTER_ID_LI | FILTER_ID_GP | \
   FILTER_ID_IP)
 
typedef enum eID_Index {
  /* Special case: Library, should never ever depend on any other type. */
  INDEX_ID_LI = 0,
 
  /* Animation types, might be used by almost all other types. */
  INDEX_ID_IP, /* Deprecated. */
  INDEX_ID_AC,
 
  /* Grease Pencil, special case, should be with the other obdata, but it can also be used by many
   * other ID types, including node trees e.g.
   * So there is no proper place for those, for now keep close to the lower end of the processing
   * hierarchy, but we may want to re-evaluate that at some point. */
  INDEX_ID_GD_LEGACY,
 
  /* Node trees, abstraction for procedural data, potentially used by many other ID types.
   *
   * NOTE: While node trees can also use many other ID types, they should not /own/ any of those,
   * while they are being owned by many other ID types. This is why they are placed here. */
  INDEX_ID_NT,
 
  /* File-wrapper types, those usually 'embed' external files in Blender, with no dependencies to
   * other ID types. */
  INDEX_ID_VF,
  INDEX_ID_TXT,
  INDEX_ID_SO,
 
  /* Image/movie types, can be used by shading ID types, but also directly by Objects, Scenes, etc.
   */
  INDEX_ID_MSK,
  INDEX_ID_IM,
  INDEX_ID_MC,
 
  /* Shading types. */
  INDEX_ID_TE,
  INDEX_ID_MA,
  INDEX_ID_LS,
  INDEX_ID_WO,
 
  /* Simulation-related types. */
  INDEX_ID_CF,
  INDEX_ID_PA,
 
  /* Shape Keys snow-flake, can be used by several obdata types. */
  INDEX_ID_KE,
 
  /* Object data types. */
  INDEX_ID_AR,
  INDEX_ID_ME,
  INDEX_ID_CU_LEGACY,
  INDEX_ID_MB,
  INDEX_ID_CV,
  INDEX_ID_PT,
  INDEX_ID_VO,
  INDEX_ID_LT,
  INDEX_ID_LA,
  INDEX_ID_CA,
  INDEX_ID_SPK,
  INDEX_ID_LP,
  INDEX_ID_GP,
 
  /* Collection and object types. */
  INDEX_ID_OB,
  INDEX_ID_GR,
 
  /* Preset-like, not-really-data types, can use many other ID types but should never be used by
   * any actual data type (besides Scene, due to tool settings). */
  INDEX_ID_PAL,
  INDEX_ID_PC,
  INDEX_ID_BR,
 
  /* Scene, after preset-like ID types because of tool settings. */
  INDEX_ID_SCE,
 
  /* UI-related types, should never be used by any other data type. */
  INDEX_ID_SCR,
  INDEX_ID_WS,
  INDEX_ID_WM,
 
  /* Special values, keep last. */
  INDEX_ID_NULL,
} eID_Index;
 
#define INDEX_ID_MAX (INDEX_ID_NULL + 1)
 
#ifdef __cplusplus
}
#endif