BLO_readfile.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"
#include "BLI_utildefines.h"
#include "BLI_utility_mixins.hh"

 
struct AssetMetaData;
struct BHead;
struct BlendfileLinkAppendContext;
struct BlendHandle;
struct BlendThumbnail;
struct FileData;
struct FileReader;
struct ID;
struct Library;
struct LinkNode;
struct ListBase;
struct Main;
struct MemFile;
struct PreviewImage;
struct ReportList;
struct Scene;
struct UserDef;
struct View3D;
struct ViewLayer;
struct WorkSpace;
struct bScreen;
struct wmWindowManager;
 
struct WorkspaceConfigFileData {
  Main *main; /* has to be freed when done reading file data */
 
  ListBase workspaces;
};
 
/* -------------------------------------------------------------------- */
 
enum eBlenFileType {
  BLENFILETYPE_BLEND = 1,
  // BLENFILETYPE_PUB = 2,     /* UNUSED */
  // BLENFILETYPE_RUNTIME = 3, /* UNUSED */
};
 
struct BlendFileData : blender::NonCopyable, blender::NonMovable {
  Main *main = nullptr;
  UserDef *user = nullptr;
 
  int fileflags = 0;
  int globalf = 0;
  char filepath[/*FILE_MAX*/ 1024] = {};

  bScreen *curscreen = nullptr;
  Scene *curscene = nullptr;
  ViewLayer *cur_view_layer = nullptr;
 
  eBlenFileType type = eBlenFileType(0);
};

struct BlendFileReadWMSetupData {
  wmWindowManager *old_wm;

  bool is_read_homefile;
  bool is_factory_startup;
};
 
struct BlendFileReadParams {
  uint skip_flags : 3; /* #eBLOReadSkip */
  uint is_startup : 1;
  uint is_factory_settings : 1;

  int undo_direction; /* #eUndoStepDir */
};
 
struct BlendFileReadReport {
  ReportList *reports;

  struct {
    double whole;
    double libraries;
    double lib_overrides;
    double lib_overrides_resync;
    double lib_overrides_recursive_resync;
  } duration;

  struct {
    int missing_libraries;
    int missing_linked_id;
    int missing_obdata;
    int missing_obproxies;

    int resynced_lib_overrides;

    int proxies_to_lib_overrides_success;
    int proxies_to_lib_overrides_failures;
    int sequence_strips_skipped;
  } count;

  int resynced_lib_overrides_libraries_count;
  bool do_resynced_lib_overrides_libraries_list;
  LinkNode *resynced_lib_overrides_libraries;
};

enum eBLOReadSkip {
  BLO_READ_SKIP_NONE = 0,
  BLO_READ_SKIP_USERDEF = (1 << 0),
  BLO_READ_SKIP_DATA = (1 << 1),
  BLO_READ_SKIP_UNDO_OLD_MAIN = (1 << 2),
};
ENUM_OPERATORS(eBLOReadSkip, BLO_READ_SKIP_UNDO_OLD_MAIN)
#define BLO_READ_SKIP_ALL (BLO_READ_SKIP_USERDEF | BLO_READ_SKIP_DATA)

BlendFileData *BLO_read_from_file(const char *filepath,
                                  eBLOReadSkip skip_flags,
                                  BlendFileReadReport *reports);
BlendFileData *BLO_read_from_memory(const void *mem,
                                    int memsize,
                                    eBLOReadSkip skip_flags,
                                    ReportList *reports);
BlendFileData *BLO_read_from_memfile(Main *oldmain,
                                     const char *filepath,
                                     MemFile *memfile,
                                     const BlendFileReadParams *params,
                                     ReportList *reports);

void BLO_blendfiledata_free(BlendFileData *bfd);

void BLO_read_do_version_after_setup(Main *new_bmain,
                                     BlendfileLinkAppendContext *lapp_context,
                                     BlendFileReadReport *reports);

 
/* -------------------------------------------------------------------- */
 
struct BLODataBlockInfo {
  char name[/*MAX_ID_NAME-2*/ 64];
  AssetMetaData *asset_data;
  bool free_asset_data;
  bool no_preview_found;
};

void BLO_datablock_info_free(BLODataBlockInfo *datablock_info);
void BLO_datablock_info_linklist_free(LinkNode * /*BLODataBlockInfo*/ datablock_infos);

BlendHandle *BLO_blendhandle_from_file(const char *filepath, BlendFileReadReport *reports);
BlendHandle *BLO_blendhandle_from_memory(const void *mem,
                                         int memsize,
                                         BlendFileReadReport *reports);

LinkNode *BLO_blendhandle_get_datablock_names(BlendHandle *bh,
                                              int ofblocktype,
 
                                              bool use_assets_only,
                                              int *r_tot_names);
LinkNode * /*BLODataBlockInfo*/ BLO_blendhandle_get_datablock_info(BlendHandle *bh,
                                                                   int ofblocktype,
                                                                   bool use_assets_only,
                                                                   int *r_tot_info_items);
PreviewImage *BLO_blendhandle_get_preview_for_id(BlendHandle *bh,
                                                 int ofblocktype,
                                                 const char *name);
LinkNode *BLO_blendhandle_get_linkable_groups(BlendHandle *bh);

void BLO_blendhandle_close(BlendHandle *bh) ATTR_NONNULL(1);

void BLO_read_invalidate_message(BlendHandle *bh, Main *bmain, const char *message);

#define BLO_read_assert_message(_check_expr, _ret_value, _bh, _bmain, _message) \
  if (_check_expr) { \
    BLO_read_invalidate_message((_bh), (_bmain), (_message)); \
    return _ret_value; \
  } \
  (void)0

 
#define BLO_GROUP_MAX 32
#define BLO_EMBEDDED_STARTUP_BLEND "<startup.blend>"
 
/* -------------------------------------------------------------------- */

enum eBLOLibLinkFlags {
  BLO_LIBLINK_USE_PLACEHOLDERS = 1 << 16,
  BLO_LIBLINK_FORCE_INDIRECT = 1 << 17,
  BLO_LIBLINK_APPEND_SET_FAKEUSER = 1 << 19,
  BLO_LIBLINK_APPEND_RECURSIVE = 1 << 20,
  BLO_LIBLINK_APPEND_LOCAL_ID_REUSE = 1 << 21,
  BLO_LIBLINK_APPEND_ASSET_DATA_CLEAR = 1 << 22,
  BLO_LIBLINK_OBDATA_INSTANCE = 1 << 24,
  BLO_LIBLINK_COLLECTION_INSTANCE = 1 << 25,
  BLO_LIBLINK_COLLECTION_NO_HIERARCHY_REBUILD = 1 << 26,
};

struct LibraryLink_Params {
  Main *bmain;
  int flag;
  int id_tag_extra;
  struct {
    Scene *scene;
    ViewLayer *view_layer;
    const View3D *v3d;
  } context;
};
 
void BLO_library_link_params_init(LibraryLink_Params *params,
                                  Main *bmain,
                                  int flag,
                                  int id_tag_extra);
void BLO_library_link_params_init_with_context(LibraryLink_Params *params,
                                               Main *bmain,
                                               int flag,
                                               int id_tag_extra,
                                               Scene *scene,
                                               ViewLayer *view_layer,
                                               const View3D *v3d);

Main *BLO_library_link_begin(BlendHandle **bh,
                             const char *filepath,
                             const LibraryLink_Params *params);
ID *BLO_library_link_named_part(Main *mainl,
                                BlendHandle **bh,
                                short idcode,
                                const char *name,
                                const LibraryLink_Params *params);
void BLO_library_link_end(Main *mainl,
                          BlendHandle **bh,
                          const LibraryLink_Params *params,
                          ReportList *reports);

struct TempLibraryContext {
  Main *bmain_base;
  BlendFileReadReport bf_reports;

  ID *temp_id;
};
 
TempLibraryContext *BLO_library_temp_load_id(Main *real_main,
                                             const char *blend_file_path,
                                             short idcode,
                                             const char *idname,
                                             ReportList *reports);
void BLO_library_temp_free(TempLibraryContext *temp_lib_ctx);

 
void *BLO_library_read_struct(FileData *fd, BHead *bh, const char *blockname);
 
using BLOExpandDoitCallback = void (*)(void *fdhandle, Main *mainvar, void *idv);

void BLO_expand_main(void *fdhandle, Main *mainvar, BLOExpandDoitCallback callback);

void BLO_update_defaults_startup_blend(Main *bmain, const char *app_template);
void BLO_update_defaults_workspace(WorkSpace *workspace, const char *app_template);

void BLO_sanitize_experimental_features_userpref_blend(UserDef *userdef);

BlendThumbnail *BLO_thumbnail_from_file(const char *filepath);

short BLO_version_from_file(const char *filepath);

struct ID_Readfile_Data {
  struct Tags {
    /* General ID reading related tags. */

    bool is_link_placeholder : 1;
    bool needs_expanding : 1;
    bool needs_linking : 1;
 
    /* Specific ID-type reading/versioning related tags. */

    bool action_assignment_needs_slot : 1;
  } tags;
};

ID_Readfile_Data::Tags BLO_readfile_id_runtime_tags(ID &id);

ID_Readfile_Data::Tags &BLO_readfile_id_runtime_tags_for_write(ID &id);

void BLO_readfile_id_runtime_data_free_all(Main &bmain);

void BLO_readfile_id_runtime_data_free(ID &id);
 
#define BLEN_THUMB_MEMSIZE_FILE(_x, _y) (sizeof(int) * (2 + (size_t)(_x) * (size_t)(_y)))