64#include <condition_variable>
82#include <fmt/format.h>
89#define DNA_DEPRECATED_ALLOW
151#define U (*((const UserDef *)&U))
157#define GENERATE_DEBUG_BLEND_FILE 0
158#define DEBUG_BLEND_FILE_SUFFIX ".debug.txt"
163#define MEM_BUFFER_SIZE MEM_SIZE_OPTIMAL(1 << 17)
164#define MEM_CHUNK_SIZE MEM_SIZE_OPTIMAL(1 << 15)
166#define ZSTD_BUFFER_SIZE (1 << 21)
167#define ZSTD_CHUNK_SIZE (1 << 20)
169#define ZSTD_COMPRESSION_LEVEL 3
183 virtual bool open(
const char *filepath) = 0;
185 virtual bool write(
const void *buf,
size_t buf_len) = 0;
193 bool open(
const char *filepath)
override;
194 bool close()
override;
195 bool write(
const void *buf,
size_t buf_len)
override;
216 return (
::close(file_handle) != -1);
220 return ::write(file_handle, buf, buf_len) == buf_len;
225 const void *uncompressed_data =
nullptr;
229 const void *compressed_data =
nullptr;
238 std::atomic<bool> compressed_done =
false;
270 std::atomic<bool> write_error =
false;
275 bool open(
const char *filepath)
override;
276 bool close()
override;
277 bool write(
const void *buf,
size_t buf_len)
override;
281 static void compress_task_run(
TaskPool *pool,
void *taskdata);
289 void write_compressed_frames();
303 void write_seekable_frames();
306void ZstdWriteWrap::compress_task_run(
TaskPool *pool,
void *taskdata)
308 auto *frame =
static_cast<ZstdFrame *
>(taskdata);
311 size_t out_buf_len = ZSTD_compressBound(frame->uncompressed_size);
313 const size_t out_size = ZSTD_compress(out_buf,
315 frame->uncompressed_data,
316 frame->uncompressed_size,
319 frame->uncompressed_data =
nullptr;
321 frame->compressed_data = out_buf;
325 if (ZSTD_isError(out_size)) [[unlikely]] {
326 ww->write_error =
true;
329 frame->compressed_size =
uint32_t(out_size);
331 frame->compressed_done =
true;
334void ZstdWriteWrap::write_compressed_frames()
338 for (
const std::unique_ptr<ZstdFrame> &frame : frames.as_span().drop_front(next_frame)) {
339 if (!frame->compressed_done) {
343 if (!write_error) [[likely]] {
345 const bool has_error = !base_wrap.write(frame->compressed_data, frame->compressed_size);
346 if (has_error) [[unlikely]] {
351 BLI_assert(frame->uncompressed_data ==
nullptr);
352 MEM_SAFE_DELETE_VOID(frame->compressed_data);
358 if (!base_wrap.open(filepath)) {
367void ZstdWriteWrap::write_u32_le(
uint32_t val)
375void ZstdWriteWrap::write_seekable_frames()
377 if (write_error) [[unlikely]] {
383 write_u32_le(0x184D2A5E);
388 const uint32_t frame_size = num_frames * 8 + 9;
389 write_u32_le(frame_size);
392 for (
const std::unique_ptr<ZstdFrame> &frame : frames) {
393 write_u32_le(frame->compressed_size);
394 write_u32_le(frame->uncompressed_size);
398 write_u32_le(num_frames);
399 const char flags = 0;
400 base_wrap.write(&flags, 1);
401 write_u32_le(0x8F92EAB1);
410 write_compressed_frames();
413 write_seekable_frames();
416 return base_wrap.close() && !write_error;
421 if (write_error) [[unlikely]] {
426 memcpy(uncompressed_data, buf, buf_len);
428 auto task = std::make_unique<ZstdFrame>();
429 task->uncompressed_data = uncompressed_data;
430 task->uncompressed_size =
uint32_t(buf_len);
431 ZstdFrame *frame_p = task.get();
433 frames.append(std::move(task));
436 write_compressed_frames();
448 WriteData *wd = MEM_new<WriteData>(__func__);
457 if ((ww ==
nullptr) || (ww->
use_buf)) {
474 if ((wd ==
nullptr) || wd->
validation_data.critical_error || (mem ==
nullptr) || memlen < 1) {
492 if (!wd->
ww->
write(mem, memlen)) {
501 MEM_delete(wd->
buffer.buf);
518 if (wd->
buffer.used_len != 0) {
535 if (adr ==
nullptr) [[unlikely]] {
540#ifdef USE_WRITE_DATA_LEN
541 wd->write_len +=
len;
544 if (wd->
buffer.buf ==
nullptr) {
551 if (wd->
buffer.used_len != 0) {
557 const size_t writelen = std::min(
len, wd->
buffer.chunk_size);
559 adr =
static_cast<const char *
>(adr) + writelen;
589 if (current !=
nullptr) {
604 if (wd->
buffer.used_len != 0) {
612 "Memfile undo step written in %.3f seconds",
654 return uint64_t(
id.session_uid) << 20;
662 const uint64_t lib_hash = XXH3_64bits(
id.lib->id.name, strlen(
id.lib->id.name));
679 "The only IDs with non-null deep-hash data should be packed linked ones");
681 "Embedded IDs should always have a null deep-hash data");
693 const MemFileChunk *prev_memchunk = curr_memchunk !=
nullptr ?
696 if (curr_memchunk ==
nullptr || curr_memchunk->
id_session_uid !=
id->session_uid ||
697 (prev_memchunk !=
nullptr &&
771 "Same identifier (old address) used several times for a same ID, skipping this "
772 "block to avoid critical corruption of the Blender file.");
781 if constexpr (
sizeof(
void *) == 4) {
796 mywrite(wd, &bhead,
sizeof(bhead));
809 if (bhead.
len > std::numeric_limits<
decltype(bh.
len)>
::max()) {
810 CLOG_ERROR(&
LOG,
"Written .blend file is corrupt, because a memory block is too large.");
829 if (stable_id == 0) {
831 stable_id = (1 << 4);
846 hint = XXH3_64bits(&hint,
sizeof(
uint64_t));
855 if (address ==
nullptr) {
863 address,
reinterpret_cast<uint64_t>(address));
901 if (adr ==
nullptr ||
data ==
nullptr || nr == 0) {
914 CLOG_ERROR(&
LOG,
"Cannot write chunks bigger than INT_MAX.");
922 const void *data_to_write;
927 const bool needs_general_pointer_remap = !wd->
use_memfile && !struct_info.
pointers.is_empty();
928 const bool has_custom_fn = bool(
fn);
929 const bool can_write_raw_runtime_data = !needs_general_pointer_remap && !has_custom_fn;
931 if (can_write_raw_runtime_data) {
933 data_to_write =
data;
936 void *buffer = buffer_owner.
buffer();
937 data_to_write = buffer;
938 memcpy(buffer,
data, len_in_bytes);
953 if (needs_general_pointer_remap) {
958 const void **p_ptr =
reinterpret_cast<const void **
>(
POINTER_OFFSET(buffer, offset));
960 *p_ptr = p_ptr_address_id;
971 bh.
len = len_in_bytes;
979 *wd->
sdna, struct_nr, data_to_write, address_id, nr, *wd->
debug_dst);
1001 const void **p_ptr =
reinterpret_cast<const void **
>(
POINTER_OFFSET(
data_.data(), offset));
1008 *p_ptr = p_ptr_address_id;
1013 const int struct_nr,
1023 const void *address_id,
1026 fmt::memory_buffer buf;
1027 fmt::appender dst{buf};
1029 fmt::format_to(dst,
"<Raw Data> at {} ({} bytes)\n", address_id,
len);
1031 constexpr int bytes_per_row = 8;
1032 const int len_digits = std::to_string(std::max<size_t>(0,
len - 1)).size();
1034 for (
size_t i = 0; i <
len; i++) {
1035 if (i % bytes_per_row == 0) {
1036 fmt::format_to(dst,
" {:{}}: ", i, len_digits);
1038 fmt::format_to(dst,
"{:02x} ",
reinterpret_cast<const uint8_t *
>(
data)[i]);
1039 if (i % bytes_per_row == bytes_per_row - 1) {
1040 fmt::format_to(dst,
"\n");
1043 if (
len % bytes_per_row != 0) {
1044 fmt::format_to(dst,
"\n");
1054 WriteData *wd,
const int filecode,
const void *
data,
const size_t len,
const void *adr)
1056 if (
data ==
nullptr ||
len == 0) {
1076 bh.
old = address_id;
1100 const int struct_nr,
1113static void writelist_id(WriteData *wd,
const int filecode,
const char *structname,
const ListBase *lb)
1115 const Link *link = lb->first;
1119 if (struct_nr == -1) {
1120 printf(
"error: cannot find SDNA code <%s>\n", structname);
1132#define writestruct_at_address(wd, filecode, struct_id, nr, adr, data, fn) \
1133 writestruct_at_address_nr(wd, filecode, dna::sdna_struct_id_get<struct_id>(), nr, adr, data, fn)
1135#define writestruct(wd, filecode, struct_id, nr, adr, fn) \
1136 writestruct_nr(wd, filecode, dna::sdna_struct_id_get<struct_id>(), nr, adr, fn)
1151 const bool use_active_win,
1161 wm = mainvar->
wm.first();
1164 if (use_active_win) {
1166 for (window =
wm->windows.first(); window; window = window->
next) {
1173 if (window ==
nullptr) {
1174 window =
wm->windows.first();
1178 window =
wm->windows.first();
1183 *r_scene = (window) ? window->
scene :
nullptr;
1203 Scene *curscene =
nullptr;
1214 memset(
data.scene_name, 0,
sizeof(
data.scene_name));
1234 ListBaseT<bUserAssetLibrary> asset_libraries_filtered = {
nullptr,
nullptr};
1235 ListBaseT<bUserAssetLibrary> asset_libraries_backup = userdef->
asset_libraries;
1244 *copied_item = asset_library_ref;
1245 BLI_addtail(&asset_libraries_filtered, copied_item);
1248 ListBaseT<bUserAssetLibrary> *asset_libraries =
const_cast<ListBaseT<bUserAssetLibrary> *
>(
1254 asset_libraries->first_ = asset_libraries_filtered.first();
1255 asset_libraries->last_ = asset_libraries_filtered.last();
1332 asset_libraries->first_ = asset_libraries_backup.first();
1333 asset_libraries->last_ = asset_libraries_backup.last();
1396 ids_used_from_library = ids;
1399 for (
ID *
id : ids) {
1404 ids_used_from_library.
append(
id);
1411 ids_used_from_library.
append(
id);
1417 bool should_write_library =
false;
1419 should_write_library =
true;
1421 else if (!
library.runtime->archived_libraries.is_empty()) {
1428 should_write_library =
true;
1433 should_write_library =
true;
1436 should_write_library = !ids_used_from_library.
is_empty();
1439 if (!should_write_library) {
1452 &
LOG,
"Attempt to re-write already written library '%s', skipping",
library.id.name);
1457 if (!
library.archive_parent_library) {
1459 &
LOG,
"Written archive library '%s' has no parent library, skipping",
library.id.name);
1465 "Written archive library '%s', while its parent library '%s' has not been written",
1467 library.archive_parent_library->id.name);
1472 written_libraries.
add(
library.archive_parent_library);
1481 for (
ID *
id : ids_used_from_library) {
1490 "Data-block '%s' from lib '%s' is not linkable, but is flagged as "
1493 library.runtime->filepath_abs);
1511 linked_ids_by_library.
add(
id.lib, &
id);
1522 wd, linked_ids_by_library, written_libraries,
library);
1524 for (
Library *archive_library :
library.runtime->archived_libraries) {
1527 wd, linked_ids_by_library, written_libraries, *archive_library);
1529 is_mainlib_written || !is_archivelib_written,
1530 "Archive libraries should never be written if their owner 'parent' library is not");
1538#ifdef WITH_BUILDINFO
1558 memset(fg.
_pad, 0,
sizeof(fg.
_pad));
1585 memcpy(fg.
subvstr, subvstr, 4);
1590#ifdef WITH_BUILDINFO
1624 ID *temp_id =
static_cast<ID *
>(buffer_.buffer());
1630 id.recalc_up_to_undo_push =
id.recalc_after_undo_push;
1631 id.recalc_after_undo_push = 0;
1636 if (is_placeholder) {
1640 temp_id->
lib =
id.lib;
1642 temp_id->
flag =
id.flag;
1670 std::stringstream ss;
1672 ss << header_size_in_bytes;
1678 const std::string header = ss.str();
1679 BLI_assert(header.size() == header_size_in_bytes);
1683 const char pointer_size_char =
sizeof(
void *) == 8 ?
'-' :
'_';
1684 const char endian_char =
'v';
1687 std::stringstream ss;
1689 ss << pointer_size_char;
1692 const std::string header = ss.str();
1700 mywrite(wd, header.data(), header.size());
1710 if (
id.id_type() ==
ID_LI) {
1747 if (
id.id_type() ==
ID_KE) {
1748 Key &shape_key = id_cast<Key &>(
id);
1752 if (shape_key.
from ==
nullptr || shape_key.
from->
us == 0) {
1764 local_ids_to_write.
append(&
id);
1766 return local_ids_to_write;
1806 const int write_flags,
1807 const bool use_userdef,
1809 std::ostream *debug_dst)
1846 for (
ID *
id : local_ids_to_write) {
1854 for (
ID *
id : local_ids_to_write) {
1890 int version_number =
min_ii(99,
U.versions);
1892 if (version_number == 0) {
1896 if (strlen(filepath) < 2) {
1901 while (version_number > 1) {
1902 SNPRINTF(filepath_tmp1,
"%s%d", filepath, version_number - 1);
1904 SNPRINTF(filepath_tmp2,
"%s%d", filepath, version_number);
1916 SNPRINTF(filepath_tmp1,
"%s%d", filepath, version_number);
1937 reports,
RPT_DEBUG,
"Checking validity of current .blend file *BEFORE* save to disk");
1944 "Critical data corruption: Conflicts and/or otherwise invalid data-blocks names "
1945 "(see console for details)");
1953 bool has_clipboard_flag =
false;
1957 "Found an ID '%s' flagged as copy/paste clipboard data while writing a regular "
1958 "blendfile, clearing the flag",
1961 has_clipboard_flag =
true;
1964 if (has_clipboard_flag) {
1967 "Found IDs flagged as copy/paste clipboard data while writing a regular "
1968 "blendfile, the flag has been cleared in these IDs");
1981 reports,
RPT_DEBUG,
"Checking validity of current .blend file *AFTER* save to disk");
1987 const char *filepath,
1988 const int write_flags,
2003 const bool relbase_valid = (mainvar->
filepath[0] !=
'\0');
2009 BKE_reportf(reports,
RPT_ERROR,
"Cannot save normal file (%s) as asset system file", tempname);
2014 void *path_list_backup =
nullptr;
2021 SNPRINTF(tempname,
"%s@", filepath);
2023 if (ww.
open(tempname) ==
false) {
2025 reports,
RPT_ERROR,
"Cannot open file %s for writing: %s", tempname, strerror(errno));
2031 if (relbase_valid ==
false) {
2040 if (relbase_valid ==
false) {
2050 if (relbase_valid) {
2062 if (relbase_valid && (
BLI_path_cmp(dir_dst, dir_src) == 0)) {
2068 if (relbase_valid ==
false) {
2079 char mainvar_filepath_orig[
FILE_MAX];
2084 if (use_save_as_copy) [[unlikely]] {
2088 switch (remap_mode) {
2096 if (relbase_valid && (
BLI_path_cmp(dir_dst, dir_src) != 0)) {
2116#if GENERATE_DEBUG_BLEND_FILE
2118 fstream debug_dst_file(debug_dst_path, std::ios::out);
2119 std::ostream *debug_dst = &debug_dst_file;
2121 std::ostream *debug_dst =
nullptr;
2126 mainvar, &ww, filepath,
nullptr,
nullptr, write_flags, use_userdef, thumb, debug_dst);
2128 const bool close_error = !ww.
close();
2130 if (path_list_backup) [[unlikely]] {
2135 if (err || close_error) {
2150 if (use_save_versions) {
2165 STRNCPY(
G.filepath_last_blend, filepath);
2177 const char *filepath,
2178 const int write_flags,
2194 bool use_userdef =
false;
2197 mainvar,
nullptr,
"", compare, current, write_flags, use_userdef,
nullptr,
nullptr);
2204 return this->wd->use_memfile;
2224 if (struct_id == -1) [[unlikely]] {
2239 const void *address,
2247 const int struct_id,
2248 const void *address,
2265 const void *address,
2284 if (struct_id == -1) [[unlikely]] {
2352 reinterpret_cast<const void *
const *
>(data_ptr),
num);
2362 if (
data !=
nullptr) {
2377 BLI_assert(this->wd->stable_address_ids.pointer_map.lookup_default(
data, address_id) ==
2379 this->wd->stable_address_ids.pointer_map.add(
data, address_id);
2384 return this->wd->filepath;
2388 const size_t approximate_size_in_bytes,
2392 if (
data ==
nullptr) {
2397 MemFile &memfile = *this->wd->mem.written_memfile;
2398 if (sharing_info !=
nullptr) {
2400 memfile.
shared_storage = MEM_new<MemFileSharedStorage>(__func__);
2412 if (sharing_info !=
nullptr) {
2413 if (!this->wd->per_id_written_shared_addresses.add(
data)) {
#define BLENDER_FILE_SUBVERSION
#define BLENDER_FILE_MIN_VERSION
#define BLENDER_FILE_VERSION
#define BLENDER_FILE_MIN_SUBVERSION
#define G_FILE_FLAG_ALL_RUNTIME
#define MAIN_ID_SESSION_UID_UNSET
File and directory operations.
#define SNPRINTF(dst, format,...)
Platform independent time functions.
Compatibility-like things for windows.
Utilities ensuring .blend file (i.e. Main) is in valid state during write and/or read process.
external readfile function prototypes.
#define BLEN_THUMB_MEMSIZE_FILE(_x, _y)
external writefile.cc function prototypes.
#define CLOG_ERROR(clg_ref,...)
#define CLOG_WARN(clg_ref,...)
#define CLOG_INFO(clg_ref,...)
#define ID_IS_OVERRIDE_LIBRARY_VIRTUAL(_id)
#define ID_IS_PACKED(_id)
#define ID_IS_OVERRIDE_LIBRARY_REAL(_id)
#define ID_IS_LINKED(_id)
#define ID_TAG_KEEP_ON_UNDO
#define ID_LINK_PLACEHOLDER
blenloader genfile private function prototypes
#define SDNA_RAW_DATA_STRUCT_INDEX
#define USER_DEVELOPER_TOOL_TEST(userdef, member)
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define POINTER_OFFSET(v, ofs)
#define BLI_assert_msg(a, msg)
ulong build_commit_timestamp
void generated_ptr(int64_t offset)
MutableSpan< char > data_
constexpr IndexRange()=default
bool add(const Key &key, const Value &value)
Value & lookup_or_add_cb(const Key &key, const CreateValueF &create_value)
bool contains(const Key &key) const
Value lookup_default_as(const ForwardKey &key, ForwardValue &&...default_value) const
Span< Value > lookup(const Key &key) const
void add(const Key &key, const Value &value)
bool open(const char *filepath) override
bool write(const void *buf, size_t buf_len) override
bool contains(const Key &key) const
void append(const T &value)
virtual bool open(const char *filepath)=0
virtual bool write(const void *buf, size_t buf_len)=0
ZstdWriteWrap(WriteWrap &base_wrap)
bool write(const void *buf, size_t buf_len) override
bool open(const char *filepath) override
void MEM_delete_void(void *vmemh)
void * MEM_new_uninitialized(size_t len, const char *str)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
void print_structs_at_address(const SDNA &sdna, int struct_id, const void *data, const void *address, int64_t element_num, std::ostream &stream)
int sdna_struct_id_get_max()
uint32_t struct_size(Span< shader::ShaderCreateInfo::PushConst > push_constants)
static void writestruct_nr(WriteData *wd, const int filecode, const int struct_nr, const int64_t nr, const void *adr, const BlendStructWriterFn fn)
void * MEM_new_uninitialized(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
static void write_id(WriteData *wd, ID *id)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
unsigned __int64 uint64_t
static uint64_t get_address_id_int(WriteData &wd, const void *address)
BLI_STATIC_ASSERT(ARRAY_SIZE(data_mode_strings)==CTX_MODE_NUM+1, "Must have a string for each context mode") const char *CTX_data_mode_string(const bContext *C)
char * STRNCPY(char(&dst)[N], const char *src)
static void mywrite_id_end(WriteData *wd, ID *)
static bool write_file_handle(Main *mainvar, WriteWrap *ww, StringRefNull filepath, MemFile *compare, MemFile *current, const int write_flags, const bool use_userdef, const BlendThumbnail *thumb, std::ostream *debug_dst)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
bool BLO_write_file(Main *mainvar, const char *filepath, int write_flags, const BlendFileWriteParams *params, ReportList *reports)
static void write_global(WriteData *wd, const int fileflags, Main *mainvar)
void copy_m3_m3(float m1[3][3], const float m2[3][3])
@ ASSET_LIBRARY_PROJECT_DEFINED
static bool write_at_address_validate(WriteData *wd, const int filecode, const void *address)
bool BKE_idtype_idcode_is_linkable(short idcode)
static bool write_library_if_needed(WriteData *wd, MultiValueMap< Library *, ID * > &linked_ids_by_library, Set< Library * > &written_libraries, Library &library)
bool BLI_exists(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void IDP_BlendWrite(BlendWriter *writer, const IDProperty *prop)
static void write_userdef(BlendWriter *writer, const UserDef *userdef)
static bool mywrite_end(WriteData *wd)
void BKE_bpath_relative_rebase(Main *bmain, const char *basedir_src, const char *basedir_dst, ReportList *reports, BPathSummary *r_summary=nullptr)
static void write_libraries(WriteData *wd, Main *bmain)
static void write_bhead(WriteData *wd, const BHead &bhead)
static void write_id_placeholder(WriteData *wd, ID *id)
static const void * get_address_id(WriteData &wd, const void *address)
static void write_blend_file_header(WriteData *wd)
bScreen * BKE_workspace_active_screen_get(const WorkSpaceInstanceHook *hook) GETTER_ATTRS
static void writedata_free(WriteData *wd)
int BLI_open(const char *filepath, int oflag, int pmode) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BKE_bpath_relative_convert(Main *bmain, const char *basedir, ReportList *reports, BPathSummary *r_summary=nullptr)
static void current_screen_compat(Main *mainvar, const bool use_active_win, bScreen **r_screen, Scene **r_scene, ViewLayer **r_view_layer)
void BKE_preferences_extension_repo_write_data(struct BlendWriter *writer, const bUserExtensionRepo *repo)
static void mywrite_flush(WriteData *wd)
void BKE_main_id_refcount_recompute(Main *bmain, bool do_linked_only)
static CLG_LogRef LOG_UNDO
void BLI_task_pool_work_and_wait(TaskPool *pool)
static void writelist_nr(WriteData *wd, const int filecode, const int struct_nr, const ListBase *lb, const BlendStructWriterFn fn)
void * BLI_task_pool_user_data(TaskPool *pool)
bool BLO_main_validate_libraries(Main *bmain, ReportList *reports)
static WriteData * mywrite_begin(WriteWrap *ww, MemFile *compare, MemFile *current)
static bool do_history(const char *filepath, ReportList *reports)
static uint64_t get_stable_pointer_hint_for_id(const ID &id, const bool is_undo)
const IDTypeInfo * BKE_idtype_get_info_from_id(const ID *id)
void void BLI_path_split_dir_part(const char *filepath, char *dir, size_t dir_maxncpy) ATTR_NONNULL(1
void void BLI_freelistN(ListBase *listbase) ATTR_NONNULL(1)
static void writedata_do_write(WriteData *wd, const void *mem, const size_t memlen)
void BKE_preferences_asset_library_write_data(struct BlendWriter *writer, const struct bUserAssetLibrary *library)
bool BLO_write_file_mem(Main *mainvar, MemFile *compare, MemFile *current, int write_flags)
@ BLO_WRITE_PATH_REMAP_RELATIVE_ALL
@ BLO_WRITE_PATH_REMAP_RELATIVE
@ BLO_WRITE_PATH_REMAP_NONE
@ BLO_WRITE_PATH_REMAP_ABSOLUTE
void BKE_report(ReportList *reports, eReportType type, const char *message)
BMesh const char void * data
void BLO_memfile_write_finalize(WriteData *wd, MemFileWriteData *mem_data)
bool BLI_path_is_abs_from_cwd(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
bool BKE_main_namemap_validate_and_fix(Main &bmain)
bool BKE_main_view_layers_synced_ensure(const Main *bmain)
int BLI_rename_overwrite(const char *from, const char *to) ATTR_NONNULL()
constexpr uint64_t generated_address_id_on_undo_flag
int BLI_path_normalize(char *path) ATTR_NONNULL(1)
@ LIBRARY_FLAG_IS_ARCHIVE
ATTR_WARN_UNUSED_RESULT const size_t num
int DNA_struct_size(const struct SDNA *sdna, int struct_index)
constexpr uint64_t generated_address_id_mask
void BLI_task_pool_free(TaskPool *pool)
_W64 unsigned int uintptr_t
static Vector< ID * > gather_local_ids_to_write(Main *bmain, const bool is_undo)
static uint64_t get_next_stable_address_id(WriteData &wd, uint64_t &hint)
static bool BLO_write_file_impl(Main *mainvar, const char *filepath, const int write_flags, const BlendFileWriteParams *params, ReportList *reports, WriteWrap &ww)
int DNA_struct_find_with_alias(const struct SDNA *sdna, StringRef str)
static uint64_t stable_id_from_hint(const uint64_t hint)
ViewLayer * BKE_view_layer_find(const Scene *scene, const char *layer_name)
@ BKE_BPATH_FOREACH_PATH_SKIP_MULTIFILE
@ BKE_BPATH_FOREACH_PATH_SKIP_LINKED
void BKE_bpath_list_restore(Main *bmain, eBPathForeachFlag flag, void *path_list_handle)
void BKE_bpath_list_free(void *path_list_handle)
static void mywrite(WriteData *wd, const void *adr, size_t len)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
static std::string get_blend_file_header()
void BLO_memfile_chunk_add(MemFileWriteData *mem_data, const char *buf, size_t size)
bool BLI_path_is_rel(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
static void prepare_stable_data_block_ids(WriteData &wd, Main &bmain)
void * BKE_bpath_list_backup(Main *bmain, eBPathForeachFlag flag)
static uint64_t get_address_id_for_undo(WriteData &wd)
@ USER_MENU_TYPE_OPERATOR
static void writedata(WriteData *wd, const int filecode, const void *data, const size_t len, const void *adr)
@ ID_TAG_NO_USER_REFCOUNT
static WriteData * writedata_new(WriteWrap *ww)
void BKE_asset_catalog_path_list_blend_write(BlendWriter *writer, const ListBaseT< AssetCatalogPathLink > &catalog_path_list)
void BLO_memfile_write_init(WriteData *wd, MemFileWriteData *mem_data, MemFile *written_memfile, MemFile *reference_memfile)
double BLI_time_now_seconds()
static void write_keymapitem(BlendWriter *writer, const wmKeyMapItem *kmi)
static void writestruct_at_address_nr(WriteData *wd, const int filecode, const int struct_nr, const int64_t nr, const void *adr, const void *data, const BlendStructWriterFn fn)
@ ID_FLAG_INDIRECT_WEAK_LINK
FunctionRef< void(BlendStructWriterVoid &struct_writer)> BlendStructWriterFn
const SDNA * DNA_sdna_current_get()
void BKE_bpath_absolute_convert(Main *bmain, const char *basedir, ReportList *reports, BPathSummary *r_summary=nullptr)
void BKE_main_id_indirect_linked_update(Main &bmain, std::optional< Span< ID * > > local_ids=std::nullopt)
void BKE_lib_override_library_operations_create(Main *bmain, ID *local, int *r_report_flags)
static void write_file_main_validate_post(Main *bmain, ReportList *reports)
static void write_file_main_validate_pre(Main &bmain, const BlendFileWriteParams ¶ms, ReportList *reports)
MINLINE int min_ii(int a, int b)
void BLI_task_pool_push(TaskPool *pool, TaskRunFunction run, void *taskdata, bool free_taskdata, TaskFreeFunction freedata)
static void mywrite_id_begin(WriteData *wd, ID *id)
static void write_renderinfo(WriteData *wd, Main *mainvar)
bool BLO_main_validate_shapekeys(Main *bmain, ReportList *reports)
static void write_thumb(WriteData *wd, const BlendThumbnail *thumb)
TaskPool * BLI_task_pool_create_background(void *userdata, eTaskPriority priority)
ulong build_commit_timestamp
static void write_raw_data_in_debug_file(WriteData *wd, const size_t len, const void *address_id, const void *data)
@ IDTYPE_FLAGS_NEVER_UNUSED
BLO_Write_IDBuffer(ID &id, bool is_undo, bool is_placeholder)
eBLO_WritePathRemap remap_mode
const BlendThumbnail * thumb
void write_pointer_array(int64_t num, const void *data)
void write_struct_by_id(int struct_id, const void *data, BlendStructWriterFn fn=nullptr)
void write_struct_array_by_id(int struct_id, int64_t array_size, const void *data, BlendStructWriterFn fn=nullptr)
void write_struct_array_by_name(const char *struct_name, int64_t array_size, const void *data, BlendStructWriterFn fn=nullptr)
int struct_id_by_name(const char *struct_name) const
void write_shared(const void *data, size_t approximate_size_in_bytes, const ImplicitSharingInfo *sharing_info, FunctionRef< void()> write_fn)
void generated_pointer_tag(const void *data)
void write_string(const char *data)
void write_struct_by_name(const char *struct_name, const void *data, BlendStructWriterFn fn=nullptr)
void write_uint8_array(int64_t num, const uint8_t *data)
void write_struct_list_by_id(int struct_id, const ListBase *list, BlendStructWriterFn fn=nullptr)
void write_int8_array(int64_t num, const int8_t *data)
void write_struct_at_address_by_id(int struct_id, const void *address, const void *data, BlendStructWriterFn fn=nullptr)
void write_float_array(int64_t num, const float *data)
void write_struct_list_by_name(const char *struct_name, ListBase *list, BlendStructWriterFn fn=nullptr)
void write_struct_array_at_address_by_id(int struct_id, int64_t array_size, const void *address, const void *data, BlendStructWriterFn fn=nullptr)
void write_float3_array(int64_t num, const float *data)
void write_char_array(int64_t num, const char *data)
void write_int16_array(int64_t num, const int16_t *data)
void write_uint32_array(int64_t num, const uint32_t *data)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_double_array(int64_t num, const double *data)
void write_struct_at_address_by_id_with_filecode(int filecode, int struct_id, const void *address, const void *data, BlendStructWriterFn fn=nullptr)
void write_raw(size_t size_in_bytes, const void *data)
void write_int32_array(int64_t num, const int32_t *data)
StringRefNull filepath() const
struct bScreen * curscreen
uint64_t build_commit_timestamp
char colorspace_scene_linear_name[64]
float colorspace_scene_linear_to_xyz[3][3]
struct ViewLayer * cur_view_layer
IDTypeBlendWriteFunction blend_write
unsigned int recalc_up_to_undo_push
float3x3 scene_linear_to_xyz
char scene_linear_name[64]
ListBaseT< wmWindowManager > wm
MainColorspace colorspace
ListBaseT< Library > libraries
ListBaseT< Scene > scenes
const c_style_mat & ptr() const
Map< uint64_t, ImplicitSharingInfoAndData > sharing_info_by_address_id
Map< uint, MemFileChunk * > id_session_uid_mapping
uint current_id_session_uid
MemFileChunk * reference_current_chunk
MemFileSharedStorage * shared_storage
char scene_name[MAX_ID_NAME - 2]
ListBaseT< bUserExtensionRepo > extension_repos
ListBaseT< bTheme > themes
ListBaseT< struct wmKeyMap > user_keymaps
ListBaseT< struct wmKeyConfigPref > user_keyconfig_prefs
ListBaseT< bUserAssetLibrary > asset_libraries
ListBaseT< bAddon > addons
ListBaseT< bPathCompare > autoexec_paths
ListBaseT< bUserScriptDirectory > script_directories
ListBaseT< uiStyle > uistyles
ListBaseT< bUserAssetShelfSettings > asset_shelves_settings
ListBaseT< bUserMenu > user_menus
std::shared_ptr< dna::pointers::PointersInDNA > sdna_pointers
Map< const void *, uint64_t > pointer_map
struct blender::WriteData::@001170002120114163277232003255130215200052024114 buffer
Set< const void * > per_id_written_shared_addresses
struct blender::WriteData::@044343357155064103211111077354243036325062231364 validation_data
WriteDataStableAddressIDs stable_address_ids
ListBaseT< AssetCatalogPathLink > enabled_catalog_paths
bool has_pointer_at_offset(int64_t offset) const
Vector< PointerInfo > pointers
wmKeyMapItem * remove_item
ListBaseT< wmKeyMapDiffItem > diff_items
ListBaseT< wmKeyMapItem > items
struct WorkSpaceInstanceHook * workspace_hook
#define ZSTD_COMPRESSION_LEVEL
#define DEBUG_BLEND_FILE_SUFFIX
#define writestruct(wd, filecode, struct_id, nr, adr, fn)
#define writestruct_at_address(wd, filecode, struct_id, nr, adr, data, fn)