1 /*************************************************************************/
2 /* resource_format_binary.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
10 /* */
11 /* Permission is hereby granted, free of charge, to any person obtaining */
12 /* a copy of this software and associated documentation files (the */
13 /* "Software"), to deal in the Software without restriction, including */
14 /* without limitation the rights to use, copy, modify, merge, publish, */
15 /* distribute, sublicense, and/or sell copies of the Software, and to */
16 /* permit persons to whom the Software is furnished to do so, subject to */
17 /* the following conditions: */
18 /* */
19 /* The above copyright notice and this permission notice shall be */
20 /* included in all copies or substantial portions of the Software. */
21 /* */
22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29 /*************************************************************************/
30
31 #include "resource_format_binary.h"
32
33 #include "core/image.h"
34 #include "core/io/file_access_compressed.h"
35 #include "core/io/marshalls.h"
36 #include "core/os/dir_access.h"
37 #include "core/project_settings.h"
38 #include "core/version.h"
39
40 //#define print_bl(m_what) print_line(m_what)
41 #define print_bl(m_what) (void)(m_what)
42
43 enum {
44
45 //numbering must be different from variant, in case new variant types are added (variant must be always contiguous for jumptable optimization)
46 VARIANT_NIL = 1,
47 VARIANT_BOOL = 2,
48 VARIANT_INT = 3,
49 VARIANT_REAL = 4,
50 VARIANT_STRING = 5,
51 VARIANT_VECTOR2 = 10,
52 VARIANT_RECT2 = 11,
53 VARIANT_VECTOR3 = 12,
54 VARIANT_PLANE = 13,
55 VARIANT_QUAT = 14,
56 VARIANT_AABB = 15,
57 VARIANT_MATRIX3 = 16,
58 VARIANT_TRANSFORM = 17,
59 VARIANT_MATRIX32 = 18,
60 VARIANT_COLOR = 20,
61 VARIANT_NODE_PATH = 22,
62 VARIANT_RID = 23,
63 VARIANT_OBJECT = 24,
64 VARIANT_INPUT_EVENT = 25,
65 VARIANT_DICTIONARY = 26,
66 VARIANT_ARRAY = 30,
67 VARIANT_RAW_ARRAY = 31,
68 VARIANT_INT_ARRAY = 32,
69 VARIANT_REAL_ARRAY = 33,
70 VARIANT_STRING_ARRAY = 34,
71 VARIANT_VECTOR3_ARRAY = 35,
72 VARIANT_COLOR_ARRAY = 36,
73 VARIANT_VECTOR2_ARRAY = 37,
74 VARIANT_INT64 = 40,
75 VARIANT_DOUBLE = 41,
76 #ifndef DISABLE_DEPRECATED
77 VARIANT_IMAGE = 21, // - no longer variant type
78 IMAGE_ENCODING_EMPTY = 0,
79 IMAGE_ENCODING_RAW = 1,
80 IMAGE_ENCODING_LOSSLESS = 2,
81 IMAGE_ENCODING_LOSSY = 3,
82 #endif
83 OBJECT_EMPTY = 0,
84 OBJECT_EXTERNAL_RESOURCE = 1,
85 OBJECT_INTERNAL_RESOURCE = 2,
86 OBJECT_EXTERNAL_RESOURCE_INDEX = 3,
87 //version 2: added 64 bits support for float and int
88 //version 3: changed nodepath encoding
89 FORMAT_VERSION = 3,
90 FORMAT_VERSION_CAN_RENAME_DEPS = 1,
91 FORMAT_VERSION_NO_NODEPATH_PROPERTY = 3,
92
93 };
94
_advance_padding(uint32_t p_len)95 void ResourceInteractiveLoaderBinary::_advance_padding(uint32_t p_len) {
96
97 uint32_t extra = 4 - (p_len % 4);
98 if (extra < 4) {
99 for (uint32_t i = 0; i < extra; i++)
100 f->get_8(); //pad to 32
101 }
102 }
103
_get_string()104 StringName ResourceInteractiveLoaderBinary::_get_string() {
105
106 uint32_t id = f->get_32();
107 if (id & 0x80000000) {
108 uint32_t len = id & 0x7FFFFFFF;
109 if ((int)len > str_buf.size()) {
110 str_buf.resize(len);
111 }
112 if (len == 0)
113 return StringName();
114 f->get_buffer((uint8_t *)&str_buf[0], len);
115 String s;
116 s.parse_utf8(&str_buf[0]);
117 return s;
118 }
119
120 return string_map[id];
121 }
122
parse_variant(Variant & r_v)123 Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
124
125 uint32_t type = f->get_32();
126 print_bl("find property of type: " + itos(type));
127
128 switch (type) {
129
130 case VARIANT_NIL: {
131
132 r_v = Variant();
133 } break;
134 case VARIANT_BOOL: {
135
136 r_v = bool(f->get_32());
137 } break;
138 case VARIANT_INT: {
139
140 r_v = int(f->get_32());
141 } break;
142 case VARIANT_INT64: {
143
144 r_v = int64_t(f->get_64());
145 } break;
146 case VARIANT_REAL: {
147
148 r_v = f->get_real();
149 } break;
150 case VARIANT_DOUBLE: {
151
152 r_v = f->get_double();
153 } break;
154 case VARIANT_STRING: {
155
156 r_v = get_unicode_string();
157 } break;
158 case VARIANT_VECTOR2: {
159
160 Vector2 v;
161 v.x = f->get_real();
162 v.y = f->get_real();
163 r_v = v;
164
165 } break;
166 case VARIANT_RECT2: {
167
168 Rect2 v;
169 v.position.x = f->get_real();
170 v.position.y = f->get_real();
171 v.size.x = f->get_real();
172 v.size.y = f->get_real();
173 r_v = v;
174
175 } break;
176 case VARIANT_VECTOR3: {
177
178 Vector3 v;
179 v.x = f->get_real();
180 v.y = f->get_real();
181 v.z = f->get_real();
182 r_v = v;
183 } break;
184 case VARIANT_PLANE: {
185
186 Plane v;
187 v.normal.x = f->get_real();
188 v.normal.y = f->get_real();
189 v.normal.z = f->get_real();
190 v.d = f->get_real();
191 r_v = v;
192 } break;
193 case VARIANT_QUAT: {
194 Quat v;
195 v.x = f->get_real();
196 v.y = f->get_real();
197 v.z = f->get_real();
198 v.w = f->get_real();
199 r_v = v;
200
201 } break;
202 case VARIANT_AABB: {
203
204 AABB v;
205 v.position.x = f->get_real();
206 v.position.y = f->get_real();
207 v.position.z = f->get_real();
208 v.size.x = f->get_real();
209 v.size.y = f->get_real();
210 v.size.z = f->get_real();
211 r_v = v;
212
213 } break;
214 case VARIANT_MATRIX32: {
215
216 Transform2D v;
217 v.elements[0].x = f->get_real();
218 v.elements[0].y = f->get_real();
219 v.elements[1].x = f->get_real();
220 v.elements[1].y = f->get_real();
221 v.elements[2].x = f->get_real();
222 v.elements[2].y = f->get_real();
223 r_v = v;
224
225 } break;
226 case VARIANT_MATRIX3: {
227
228 Basis v;
229 v.elements[0].x = f->get_real();
230 v.elements[0].y = f->get_real();
231 v.elements[0].z = f->get_real();
232 v.elements[1].x = f->get_real();
233 v.elements[1].y = f->get_real();
234 v.elements[1].z = f->get_real();
235 v.elements[2].x = f->get_real();
236 v.elements[2].y = f->get_real();
237 v.elements[2].z = f->get_real();
238 r_v = v;
239
240 } break;
241 case VARIANT_TRANSFORM: {
242
243 Transform v;
244 v.basis.elements[0].x = f->get_real();
245 v.basis.elements[0].y = f->get_real();
246 v.basis.elements[0].z = f->get_real();
247 v.basis.elements[1].x = f->get_real();
248 v.basis.elements[1].y = f->get_real();
249 v.basis.elements[1].z = f->get_real();
250 v.basis.elements[2].x = f->get_real();
251 v.basis.elements[2].y = f->get_real();
252 v.basis.elements[2].z = f->get_real();
253 v.origin.x = f->get_real();
254 v.origin.y = f->get_real();
255 v.origin.z = f->get_real();
256 r_v = v;
257 } break;
258 case VARIANT_COLOR: {
259
260 Color v;
261 v.r = f->get_real();
262 v.g = f->get_real();
263 v.b = f->get_real();
264 v.a = f->get_real();
265 r_v = v;
266
267 } break;
268
269 case VARIANT_NODE_PATH: {
270
271 Vector<StringName> names;
272 Vector<StringName> subnames;
273 bool absolute;
274
275 int name_count = f->get_16();
276 uint32_t subname_count = f->get_16();
277 absolute = subname_count & 0x8000;
278 subname_count &= 0x7FFF;
279 if (ver_format < FORMAT_VERSION_NO_NODEPATH_PROPERTY) {
280 subname_count += 1; // has a property field, so we should count it as well
281 }
282
283 for (int i = 0; i < name_count; i++)
284 names.push_back(_get_string());
285 for (uint32_t i = 0; i < subname_count; i++)
286 subnames.push_back(_get_string());
287
288 NodePath np = NodePath(names, subnames, absolute);
289
290 r_v = np;
291
292 } break;
293 case VARIANT_RID: {
294
295 r_v = f->get_32();
296 } break;
297 case VARIANT_OBJECT: {
298
299 uint32_t objtype = f->get_32();
300
301 switch (objtype) {
302
303 case OBJECT_EMPTY: {
304 //do none
305
306 } break;
307 case OBJECT_INTERNAL_RESOURCE: {
308 uint32_t index = f->get_32();
309 String path = res_path + "::" + itos(index);
310 RES res = ResourceLoader::load(path);
311 if (res.is_null()) {
312 WARN_PRINT(String("Couldn't load resource: " + path).utf8().get_data());
313 }
314 r_v = res;
315
316 } break;
317 case OBJECT_EXTERNAL_RESOURCE: {
318 //old file format, still around for compatibility
319
320 String exttype = get_unicode_string();
321 String path = get_unicode_string();
322
323 if (path.find("://") == -1 && path.is_rel_path()) {
324 // path is relative to file being loaded, so convert to a resource path
325 path = ProjectSettings::get_singleton()->localize_path(res_path.get_base_dir().plus_file(path));
326 }
327
328 if (remaps.find(path)) {
329 path = remaps[path];
330 }
331
332 RES res = ResourceLoader::load(path, exttype);
333
334 if (res.is_null()) {
335 WARN_PRINT(String("Couldn't load resource: " + path).utf8().get_data());
336 }
337 r_v = res;
338
339 } break;
340 case OBJECT_EXTERNAL_RESOURCE_INDEX: {
341 //new file format, just refers to an index in the external list
342 int erindex = f->get_32();
343
344 if (erindex < 0 || erindex >= external_resources.size()) {
345 WARN_PRINT("Broken external resource! (index out of size)");
346 r_v = Variant();
347 } else {
348
349 String exttype = external_resources[erindex].type;
350 String path = external_resources[erindex].path;
351
352 if (path.find("://") == -1 && path.is_rel_path()) {
353 // path is relative to file being loaded, so convert to a resource path
354 path = ProjectSettings::get_singleton()->localize_path(res_path.get_base_dir().plus_file(path));
355 }
356
357 RES res = ResourceLoader::load(path, exttype);
358
359 if (res.is_null()) {
360 WARN_PRINT(String("Couldn't load resource: " + path).utf8().get_data());
361 }
362 r_v = res;
363 }
364
365 } break;
366 default: {
367
368 ERR_FAIL_V(ERR_FILE_CORRUPT);
369 } break;
370 }
371
372 } break;
373 case VARIANT_DICTIONARY: {
374
375 uint32_t len = f->get_32();
376 Dictionary d; //last bit means shared
377 len &= 0x7FFFFFFF;
378 for (uint32_t i = 0; i < len; i++) {
379 Variant key;
380 Error err = parse_variant(key);
381 ERR_FAIL_COND_V_MSG(err, ERR_FILE_CORRUPT, "Error when trying to parse Variant.");
382 Variant value;
383 err = parse_variant(value);
384 ERR_FAIL_COND_V_MSG(err, ERR_FILE_CORRUPT, "Error when trying to parse Variant.");
385 d[key] = value;
386 }
387 r_v = d;
388 } break;
389 case VARIANT_ARRAY: {
390
391 uint32_t len = f->get_32();
392 Array a; //last bit means shared
393 len &= 0x7FFFFFFF;
394 a.resize(len);
395 for (uint32_t i = 0; i < len; i++) {
396 Variant val;
397 Error err = parse_variant(val);
398 ERR_FAIL_COND_V_MSG(err, ERR_FILE_CORRUPT, "Error when trying to parse Variant.");
399 a[i] = val;
400 }
401 r_v = a;
402
403 } break;
404 case VARIANT_RAW_ARRAY: {
405
406 uint32_t len = f->get_32();
407
408 PoolVector<uint8_t> array;
409 array.resize(len);
410 PoolVector<uint8_t>::Write w = array.write();
411 f->get_buffer(w.ptr(), len);
412 _advance_padding(len);
413 w.release();
414 r_v = array;
415
416 } break;
417 case VARIANT_INT_ARRAY: {
418
419 uint32_t len = f->get_32();
420
421 PoolVector<int> array;
422 array.resize(len);
423 PoolVector<int>::Write w = array.write();
424 f->get_buffer((uint8_t *)w.ptr(), len * 4);
425 #ifdef BIG_ENDIAN_ENABLED
426 {
427 uint32_t *ptr = (uint32_t *)w.ptr();
428 for (int i = 0; i < len; i++) {
429
430 ptr[i] = BSWAP32(ptr[i]);
431 }
432 }
433
434 #endif
435 w.release();
436 r_v = array;
437 } break;
438 case VARIANT_REAL_ARRAY: {
439
440 uint32_t len = f->get_32();
441
442 PoolVector<real_t> array;
443 array.resize(len);
444 PoolVector<real_t>::Write w = array.write();
445 f->get_buffer((uint8_t *)w.ptr(), len * sizeof(real_t));
446 #ifdef BIG_ENDIAN_ENABLED
447 {
448 uint32_t *ptr = (uint32_t *)w.ptr();
449 for (int i = 0; i < len; i++) {
450
451 ptr[i] = BSWAP32(ptr[i]);
452 }
453 }
454
455 #endif
456
457 w.release();
458 r_v = array;
459 } break;
460 case VARIANT_STRING_ARRAY: {
461
462 uint32_t len = f->get_32();
463 PoolVector<String> array;
464 array.resize(len);
465 PoolVector<String>::Write w = array.write();
466 for (uint32_t i = 0; i < len; i++)
467 w[i] = get_unicode_string();
468 w.release();
469 r_v = array;
470
471 } break;
472 case VARIANT_VECTOR2_ARRAY: {
473
474 uint32_t len = f->get_32();
475
476 PoolVector<Vector2> array;
477 array.resize(len);
478 PoolVector<Vector2>::Write w = array.write();
479 if (sizeof(Vector2) == 8) {
480 f->get_buffer((uint8_t *)w.ptr(), len * sizeof(real_t) * 2);
481 #ifdef BIG_ENDIAN_ENABLED
482 {
483 uint32_t *ptr = (uint32_t *)w.ptr();
484 for (int i = 0; i < len * 2; i++) {
485
486 ptr[i] = BSWAP32(ptr[i]);
487 }
488 }
489
490 #endif
491
492 } else {
493 ERR_FAIL_V_MSG(ERR_UNAVAILABLE, "Vector2 size is NOT 8!");
494 }
495 w.release();
496 r_v = array;
497
498 } break;
499 case VARIANT_VECTOR3_ARRAY: {
500
501 uint32_t len = f->get_32();
502
503 PoolVector<Vector3> array;
504 array.resize(len);
505 PoolVector<Vector3>::Write w = array.write();
506 if (sizeof(Vector3) == 12) {
507 f->get_buffer((uint8_t *)w.ptr(), len * sizeof(real_t) * 3);
508 #ifdef BIG_ENDIAN_ENABLED
509 {
510 uint32_t *ptr = (uint32_t *)w.ptr();
511 for (int i = 0; i < len * 3; i++) {
512
513 ptr[i] = BSWAP32(ptr[i]);
514 }
515 }
516
517 #endif
518
519 } else {
520 ERR_FAIL_V_MSG(ERR_UNAVAILABLE, "Vector3 size is NOT 12!");
521 }
522 w.release();
523 r_v = array;
524
525 } break;
526 case VARIANT_COLOR_ARRAY: {
527
528 uint32_t len = f->get_32();
529
530 PoolVector<Color> array;
531 array.resize(len);
532 PoolVector<Color>::Write w = array.write();
533 if (sizeof(Color) == 16) {
534 f->get_buffer((uint8_t *)w.ptr(), len * sizeof(real_t) * 4);
535 #ifdef BIG_ENDIAN_ENABLED
536 {
537 uint32_t *ptr = (uint32_t *)w.ptr();
538 for (int i = 0; i < len * 4; i++) {
539
540 ptr[i] = BSWAP32(ptr[i]);
541 }
542 }
543
544 #endif
545
546 } else {
547 ERR_FAIL_V_MSG(ERR_UNAVAILABLE, "Color size is NOT 16!");
548 }
549 w.release();
550 r_v = array;
551 } break;
552 #ifndef DISABLE_DEPRECATED
553 case VARIANT_IMAGE: {
554 uint32_t encoding = f->get_32();
555 if (encoding == IMAGE_ENCODING_EMPTY) {
556 r_v = Ref<Image>();
557 break;
558 } else if (encoding == IMAGE_ENCODING_RAW) {
559 uint32_t width = f->get_32();
560 uint32_t height = f->get_32();
561 uint32_t mipmaps = f->get_32();
562 uint32_t format = f->get_32();
563 const uint32_t format_version_shift = 24;
564 const uint32_t format_version_mask = format_version_shift - 1;
565
566 uint32_t format_version = format >> format_version_shift;
567
568 const uint32_t current_version = 0;
569 if (format_version > current_version) {
570
571 ERR_PRINT("Format version for encoded binary image is too new.");
572 return ERR_PARSE_ERROR;
573 }
574
575 Image::Format fmt = Image::Format(format & format_version_mask); //if format changes, we can add a compatibility bit on top
576
577 uint32_t datalen = f->get_32();
578
579 PoolVector<uint8_t> imgdata;
580 imgdata.resize(datalen);
581 PoolVector<uint8_t>::Write w = imgdata.write();
582 f->get_buffer(w.ptr(), datalen);
583 _advance_padding(datalen);
584 w.release();
585
586 Ref<Image> image;
587 image.instance();
588 image->create(width, height, mipmaps, fmt, imgdata);
589 r_v = image;
590
591 } else {
592 //compressed
593 PoolVector<uint8_t> data;
594 data.resize(f->get_32());
595 PoolVector<uint8_t>::Write w = data.write();
596 f->get_buffer(w.ptr(), data.size());
597 w.release();
598
599 Ref<Image> image;
600
601 if (encoding == IMAGE_ENCODING_LOSSY && Image::lossy_unpacker) {
602
603 image = Image::lossy_unpacker(data);
604 } else if (encoding == IMAGE_ENCODING_LOSSLESS && Image::lossless_unpacker) {
605
606 image = Image::lossless_unpacker(data);
607 }
608 _advance_padding(data.size());
609
610 r_v = image;
611 }
612
613 } break;
614 #endif
615 default: {
616 ERR_FAIL_V(ERR_FILE_CORRUPT);
617 } break;
618 }
619
620 return OK; //never reach anyway
621 }
622
set_local_path(const String & p_local_path)623 void ResourceInteractiveLoaderBinary::set_local_path(const String &p_local_path) {
624
625 res_path = p_local_path;
626 }
627
get_resource()628 Ref<Resource> ResourceInteractiveLoaderBinary::get_resource() {
629
630 return resource;
631 }
poll()632 Error ResourceInteractiveLoaderBinary::poll() {
633
634 if (error != OK)
635 return error;
636
637 int s = stage;
638
639 if (s < external_resources.size()) {
640
641 String path = external_resources[s].path;
642
643 if (remaps.has(path)) {
644 path = remaps[path];
645 }
646 RES res = ResourceLoader::load(path, external_resources[s].type);
647 if (res.is_null()) {
648
649 if (!ResourceLoader::get_abort_on_missing_resources()) {
650
651 ResourceLoader::notify_dependency_error(local_path, path, external_resources[s].type);
652 } else {
653
654 error = ERR_FILE_MISSING_DEPENDENCIES;
655 ERR_FAIL_V_MSG(error, "Can't load dependency: " + path + ".");
656 }
657
658 } else {
659 resource_cache.push_back(res);
660 }
661
662 stage++;
663 return error;
664 }
665
666 s -= external_resources.size();
667
668 if (s >= internal_resources.size()) {
669
670 error = ERR_BUG;
671 ERR_FAIL_COND_V(s >= internal_resources.size(), error);
672 }
673
674 bool main = s == (internal_resources.size() - 1);
675
676 //maybe it is loaded already
677 String path;
678 int subindex = 0;
679
680 if (!main) {
681
682 path = internal_resources[s].path;
683 if (path.begins_with("local://")) {
684 path = path.replace_first("local://", "");
685 subindex = path.to_int();
686 path = res_path + "::" + path;
687 }
688
689 if (ResourceCache::has(path)) {
690 //already loaded, don't do anything
691 stage++;
692 error = OK;
693 return error;
694 }
695 } else {
696
697 if (!ResourceCache::has(res_path))
698 path = res_path;
699 }
700
701 uint64_t offset = internal_resources[s].offset;
702
703 f->seek(offset);
704
705 String t = get_unicode_string();
706
707 Object *obj = ClassDB::instance(t);
708 if (!obj) {
709 error = ERR_FILE_CORRUPT;
710 ERR_FAIL_V_MSG(ERR_FILE_CORRUPT, local_path + ":Resource of unrecognized type in file: " + t + ".");
711 }
712
713 Resource *r = Object::cast_to<Resource>(obj);
714 if (!r) {
715 String obj_class = obj->get_class();
716 error = ERR_FILE_CORRUPT;
717 memdelete(obj); //bye
718 ERR_FAIL_V_MSG(ERR_FILE_CORRUPT, local_path + ":Resource type in resource field not a resource, type is: " + obj_class + ".");
719 }
720
721 RES res = RES(r);
722
723 r->set_path(path);
724 r->set_subindex(subindex);
725
726 int pc = f->get_32();
727
728 //set properties
729
730 for (int i = 0; i < pc; i++) {
731
732 StringName name = _get_string();
733
734 if (name == StringName()) {
735 error = ERR_FILE_CORRUPT;
736 ERR_FAIL_V(ERR_FILE_CORRUPT);
737 }
738
739 Variant value;
740
741 error = parse_variant(value);
742 if (error)
743 return error;
744
745 res->set(name, value);
746 }
747 #ifdef TOOLS_ENABLED
748 res->set_edited(false);
749 #endif
750 stage++;
751
752 resource_cache.push_back(res);
753
754 if (main) {
755
756 f->close();
757 resource = res;
758 resource->set_as_translation_remapped(translation_remapped);
759 error = ERR_FILE_EOF;
760
761 } else {
762 error = OK;
763 }
764
765 return OK;
766 }
get_stage() const767 int ResourceInteractiveLoaderBinary::get_stage() const {
768
769 return stage;
770 }
get_stage_count() const771 int ResourceInteractiveLoaderBinary::get_stage_count() const {
772
773 return external_resources.size() + internal_resources.size();
774 }
775
set_translation_remapped(bool p_remapped)776 void ResourceInteractiveLoaderBinary::set_translation_remapped(bool p_remapped) {
777
778 translation_remapped = p_remapped;
779 }
780
save_ustring(FileAccess * f,const String & p_string)781 static void save_ustring(FileAccess *f, const String &p_string) {
782
783 CharString utf8 = p_string.utf8();
784 f->store_32(utf8.length() + 1);
785 f->store_buffer((const uint8_t *)utf8.get_data(), utf8.length() + 1);
786 }
787
get_ustring(FileAccess * f)788 static String get_ustring(FileAccess *f) {
789
790 int len = f->get_32();
791 Vector<char> str_buf;
792 str_buf.resize(len);
793 f->get_buffer((uint8_t *)&str_buf[0], len);
794 String s;
795 s.parse_utf8(&str_buf[0]);
796 return s;
797 }
798
get_unicode_string()799 String ResourceInteractiveLoaderBinary::get_unicode_string() {
800
801 int len = f->get_32();
802 if (len > str_buf.size()) {
803 str_buf.resize(len);
804 }
805 if (len == 0)
806 return String();
807 f->get_buffer((uint8_t *)&str_buf[0], len);
808 String s;
809 s.parse_utf8(&str_buf[0]);
810 return s;
811 }
812
get_dependencies(FileAccess * p_f,List<String> * p_dependencies,bool p_add_types)813 void ResourceInteractiveLoaderBinary::get_dependencies(FileAccess *p_f, List<String> *p_dependencies, bool p_add_types) {
814
815 open(p_f);
816 if (error)
817 return;
818
819 for (int i = 0; i < external_resources.size(); i++) {
820
821 String dep = external_resources[i].path;
822
823 if (p_add_types && external_resources[i].type != String()) {
824 dep += "::" + external_resources[i].type;
825 }
826
827 p_dependencies->push_back(dep);
828 }
829 }
830
open(FileAccess * p_f)831 void ResourceInteractiveLoaderBinary::open(FileAccess *p_f) {
832
833 error = OK;
834
835 f = p_f;
836 uint8_t header[4];
837 f->get_buffer(header, 4);
838 if (header[0] == 'R' && header[1] == 'S' && header[2] == 'C' && header[3] == 'C') {
839 // Compressed.
840 FileAccessCompressed *fac = memnew(FileAccessCompressed);
841 error = fac->open_after_magic(f);
842 if (error != OK) {
843 memdelete(fac);
844 f->close();
845 ERR_FAIL_MSG("Failed to open binary resource file: " + local_path + ".");
846 }
847 f = fac;
848
849 } else if (header[0] != 'R' || header[1] != 'S' || header[2] != 'R' || header[3] != 'C') {
850 // Not normal.
851 error = ERR_FILE_UNRECOGNIZED;
852 f->close();
853 ERR_FAIL_MSG("Unrecognized binary resource file: " + local_path + ".");
854 }
855
856 bool big_endian = f->get_32();
857 bool use_real64 = f->get_32();
858
859 f->set_endian_swap(big_endian != 0); //read big endian if saved as big endian
860
861 uint32_t ver_major = f->get_32();
862 uint32_t ver_minor = f->get_32();
863 ver_format = f->get_32();
864
865 print_bl("big endian: " + itos(big_endian));
866 #ifdef BIG_ENDIAN_ENABLED
867 print_bl("endian swap: " + itos(!big_endian));
868 #else
869 print_bl("endian swap: " + itos(big_endian));
870 #endif
871 print_bl("real64: " + itos(use_real64));
872 print_bl("major: " + itos(ver_major));
873 print_bl("minor: " + itos(ver_minor));
874 print_bl("format: " + itos(ver_format));
875
876 if (ver_format > FORMAT_VERSION || ver_major > VERSION_MAJOR) {
877
878 f->close();
879 ERR_FAIL_MSG("File format '" + itos(FORMAT_VERSION) + "." + itos(ver_major) + "." + itos(ver_minor) + "' is too new! Please upgrade to a new engine version: " + local_path + ".");
880 }
881
882 type = get_unicode_string();
883
884 print_bl("type: " + type);
885
886 importmd_ofs = f->get_64();
887 for (int i = 0; i < 14; i++)
888 f->get_32(); //skip a few reserved fields
889
890 uint32_t string_table_size = f->get_32();
891 string_map.resize(string_table_size);
892 for (uint32_t i = 0; i < string_table_size; i++) {
893
894 StringName s = get_unicode_string();
895 string_map.write[i] = s;
896 }
897
898 print_bl("strings: " + itos(string_table_size));
899
900 uint32_t ext_resources_size = f->get_32();
901 for (uint32_t i = 0; i < ext_resources_size; i++) {
902
903 ExtResource er;
904 er.type = get_unicode_string();
905
906 er.path = get_unicode_string();
907
908 external_resources.push_back(er);
909 }
910
911 print_bl("ext resources: " + itos(ext_resources_size));
912 uint32_t int_resources_size = f->get_32();
913
914 for (uint32_t i = 0; i < int_resources_size; i++) {
915
916 IntResource ir;
917 ir.path = get_unicode_string();
918 ir.offset = f->get_64();
919 internal_resources.push_back(ir);
920 }
921
922 print_bl("int resources: " + itos(int_resources_size));
923
924 if (f->eof_reached()) {
925
926 error = ERR_FILE_CORRUPT;
927 f->close();
928 ERR_FAIL_MSG("Premature end of file (EOF): " + local_path + ".");
929 }
930 }
931
recognize(FileAccess * p_f)932 String ResourceInteractiveLoaderBinary::recognize(FileAccess *p_f) {
933
934 error = OK;
935
936 f = p_f;
937 uint8_t header[4];
938 f->get_buffer(header, 4);
939 if (header[0] == 'R' && header[1] == 'S' && header[2] == 'C' && header[3] == 'C') {
940 // Compressed.
941 FileAccessCompressed *fac = memnew(FileAccessCompressed);
942 error = fac->open_after_magic(f);
943 if (error != OK) {
944 memdelete(fac);
945 f->close();
946 return "";
947 }
948 f = fac;
949
950 } else if (header[0] != 'R' || header[1] != 'S' || header[2] != 'R' || header[3] != 'C') {
951 // Not normal.
952 error = ERR_FILE_UNRECOGNIZED;
953 f->close();
954 return "";
955 }
956
957 bool big_endian = f->get_32();
958 f->get_32(); // use_real64
959
960 f->set_endian_swap(big_endian != 0); //read big endian if saved as big endian
961
962 uint32_t ver_major = f->get_32();
963 f->get_32(); // ver_minor
964 uint32_t ver_format = f->get_32();
965
966 if (ver_format > FORMAT_VERSION || ver_major > VERSION_MAJOR) {
967
968 f->close();
969 return "";
970 }
971
972 String type = get_unicode_string();
973
974 return type;
975 }
976
ResourceInteractiveLoaderBinary()977 ResourceInteractiveLoaderBinary::ResourceInteractiveLoaderBinary() :
978 translation_remapped(false),
979 f(NULL),
980 error(OK),
981 stage(0) {
982 }
983
~ResourceInteractiveLoaderBinary()984 ResourceInteractiveLoaderBinary::~ResourceInteractiveLoaderBinary() {
985
986 if (f)
987 memdelete(f);
988 }
989
load_interactive(const String & p_path,const String & p_original_path,Error * r_error)990 Ref<ResourceInteractiveLoader> ResourceFormatLoaderBinary::load_interactive(const String &p_path, const String &p_original_path, Error *r_error) {
991
992 if (r_error)
993 *r_error = ERR_FILE_CANT_OPEN;
994
995 Error err;
996 FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
997
998 ERR_FAIL_COND_V_MSG(err != OK, Ref<ResourceInteractiveLoader>(), "Cannot open file '" + p_path + "'.");
999
1000 Ref<ResourceInteractiveLoaderBinary> ria = memnew(ResourceInteractiveLoaderBinary);
1001 String path = p_original_path != "" ? p_original_path : p_path;
1002 ria->local_path = ProjectSettings::get_singleton()->localize_path(path);
1003 ria->res_path = ria->local_path;
1004 //ria->set_local_path( Globals::get_singleton()->localize_path(p_path) );
1005 ria->open(f);
1006
1007 return ria;
1008 }
1009
get_recognized_extensions_for_type(const String & p_type,List<String> * p_extensions) const1010 void ResourceFormatLoaderBinary::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const {
1011
1012 if (p_type == "") {
1013 get_recognized_extensions(p_extensions);
1014 return;
1015 }
1016
1017 List<String> extensions;
1018 ClassDB::get_extensions_for_type(p_type, &extensions);
1019
1020 extensions.sort();
1021
1022 for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
1023 String ext = E->get().to_lower();
1024 p_extensions->push_back(ext);
1025 }
1026 }
get_recognized_extensions(List<String> * p_extensions) const1027 void ResourceFormatLoaderBinary::get_recognized_extensions(List<String> *p_extensions) const {
1028
1029 List<String> extensions;
1030 ClassDB::get_resource_base_extensions(&extensions);
1031 extensions.sort();
1032
1033 for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
1034 String ext = E->get().to_lower();
1035 p_extensions->push_back(ext);
1036 }
1037 }
1038
handles_type(const String & p_type) const1039 bool ResourceFormatLoaderBinary::handles_type(const String &p_type) const {
1040
1041 return true; //handles all
1042 }
1043
get_dependencies(const String & p_path,List<String> * p_dependencies,bool p_add_types)1044 void ResourceFormatLoaderBinary::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) {
1045
1046 FileAccess *f = FileAccess::open(p_path, FileAccess::READ);
1047 ERR_FAIL_COND_MSG(!f, "Cannot open file '" + p_path + "'.");
1048
1049 Ref<ResourceInteractiveLoaderBinary> ria = memnew(ResourceInteractiveLoaderBinary);
1050 ria->local_path = ProjectSettings::get_singleton()->localize_path(p_path);
1051 ria->res_path = ria->local_path;
1052 //ria->set_local_path( Globals::get_singleton()->localize_path(p_path) );
1053 ria->get_dependencies(f, p_dependencies, p_add_types);
1054 }
1055
rename_dependencies(const String & p_path,const Map<String,String> & p_map)1056 Error ResourceFormatLoaderBinary::rename_dependencies(const String &p_path, const Map<String, String> &p_map) {
1057
1058 //Error error=OK;
1059
1060 FileAccess *f = FileAccess::open(p_path, FileAccess::READ);
1061 ERR_FAIL_COND_V_MSG(!f, ERR_CANT_OPEN, "Cannot open file '" + p_path + "'.");
1062
1063 FileAccess *fw = NULL; //=FileAccess::open(p_path+".depren");
1064
1065 String local_path = p_path.get_base_dir();
1066
1067 uint8_t header[4];
1068 f->get_buffer(header, 4);
1069 if (header[0] == 'R' && header[1] == 'S' && header[2] == 'C' && header[3] == 'C') {
1070 // Compressed.
1071 FileAccessCompressed *fac = memnew(FileAccessCompressed);
1072 Error err = fac->open_after_magic(f);
1073 if (err != OK) {
1074 memdelete(fac);
1075 memdelete(f);
1076 ERR_FAIL_V_MSG(err, "Cannot open file '" + p_path + "'.");
1077 }
1078 f = fac;
1079
1080 FileAccessCompressed *facw = memnew(FileAccessCompressed);
1081 facw->configure("RSCC");
1082 err = facw->_open(p_path + ".depren", FileAccess::WRITE);
1083 if (err) {
1084 memdelete(fac);
1085 memdelete(facw);
1086 ERR_FAIL_COND_V_MSG(err, ERR_FILE_CORRUPT, "Cannot create file '" + p_path + ".depren'.");
1087 }
1088
1089 fw = facw;
1090
1091 } else if (header[0] != 'R' || header[1] != 'S' || header[2] != 'R' || header[3] != 'C') {
1092 // Not normal.
1093 memdelete(f);
1094 ERR_FAIL_V_MSG(ERR_FILE_UNRECOGNIZED, "Unrecognized binary resource file '" + local_path + "'.");
1095 } else {
1096 fw = FileAccess::open(p_path + ".depren", FileAccess::WRITE);
1097 if (!fw) {
1098 memdelete(f);
1099 }
1100 ERR_FAIL_COND_V_MSG(!fw, ERR_CANT_CREATE, "Cannot create file '" + p_path + ".depren'.");
1101
1102 uint8_t magic[4] = { 'R', 'S', 'R', 'C' };
1103 fw->store_buffer(magic, 4);
1104 }
1105
1106 bool big_endian = f->get_32();
1107 bool use_real64 = f->get_32();
1108
1109 f->set_endian_swap(big_endian != 0); //read big endian if saved as big endian
1110 #ifdef BIG_ENDIAN_ENABLED
1111 fw->store_32(!big_endian);
1112 #else
1113 fw->store_32(big_endian);
1114 #endif
1115 fw->set_endian_swap(big_endian != 0);
1116 fw->store_32(use_real64); //use real64
1117
1118 uint32_t ver_major = f->get_32();
1119 uint32_t ver_minor = f->get_32();
1120 uint32_t ver_format = f->get_32();
1121
1122 if (ver_format < FORMAT_VERSION_CAN_RENAME_DEPS) {
1123
1124 memdelete(f);
1125 memdelete(fw);
1126 DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
1127 da->remove(p_path + ".depren");
1128 memdelete(da);
1129 //use the old approach
1130
1131 WARN_PRINTS("This file is old, so it can't refactor dependencies, opening and resaving '" + p_path + "'.");
1132
1133 Error err;
1134 f = FileAccess::open(p_path, FileAccess::READ, &err);
1135
1136 ERR_FAIL_COND_V_MSG(err != OK, ERR_FILE_CANT_OPEN, "Cannot open file '" + p_path + "'.");
1137
1138 Ref<ResourceInteractiveLoaderBinary> ria = memnew(ResourceInteractiveLoaderBinary);
1139 ria->local_path = ProjectSettings::get_singleton()->localize_path(p_path);
1140 ria->res_path = ria->local_path;
1141 ria->remaps = p_map;
1142 //ria->set_local_path( Globals::get_singleton()->localize_path(p_path) );
1143 ria->open(f);
1144
1145 err = ria->poll();
1146
1147 while (err == OK) {
1148 err = ria->poll();
1149 }
1150
1151 ERR_FAIL_COND_V(err != ERR_FILE_EOF, ERR_FILE_CORRUPT);
1152 RES res = ria->get_resource();
1153 ERR_FAIL_COND_V(!res.is_valid(), ERR_FILE_CORRUPT);
1154
1155 return ResourceFormatSaverBinary::singleton->save(p_path, res);
1156 }
1157
1158 if (ver_format > FORMAT_VERSION || ver_major > VERSION_MAJOR) {
1159
1160 memdelete(f);
1161 memdelete(fw);
1162 ERR_FAIL_V_MSG(ERR_FILE_UNRECOGNIZED, "File format '" + itos(FORMAT_VERSION) + "." + itos(ver_major) + "." + itos(ver_minor) + "' is too new! Please upgrade to a new engine version: " + local_path + ".");
1163 }
1164
1165 // Since we're not actually converting the file contents, leave the version
1166 // numbers in the file untouched.
1167 fw->store_32(ver_major);
1168 fw->store_32(ver_minor);
1169 fw->store_32(ver_format);
1170
1171 save_ustring(fw, get_ustring(f)); //type
1172
1173 size_t md_ofs = f->get_position();
1174 size_t importmd_ofs = f->get_64();
1175 fw->store_64(0); //metadata offset
1176
1177 for (int i = 0; i < 14; i++) {
1178 fw->store_32(0);
1179 f->get_32();
1180 }
1181
1182 //string table
1183 uint32_t string_table_size = f->get_32();
1184
1185 fw->store_32(string_table_size);
1186
1187 for (uint32_t i = 0; i < string_table_size; i++) {
1188
1189 String s = get_ustring(f);
1190 save_ustring(fw, s);
1191 }
1192
1193 //external resources
1194 uint32_t ext_resources_size = f->get_32();
1195 fw->store_32(ext_resources_size);
1196 for (uint32_t i = 0; i < ext_resources_size; i++) {
1197
1198 String type = get_ustring(f);
1199 String path = get_ustring(f);
1200
1201 bool relative = false;
1202 if (!path.begins_with("res://")) {
1203 path = local_path.plus_file(path).simplify_path();
1204 relative = true;
1205 }
1206
1207 if (p_map.has(path)) {
1208 String np = p_map[path];
1209 path = np;
1210 }
1211
1212 if (relative) {
1213 //restore relative
1214 path = local_path.path_to_file(path);
1215 }
1216
1217 save_ustring(fw, type);
1218 save_ustring(fw, path);
1219 }
1220
1221 int64_t size_diff = (int64_t)fw->get_position() - (int64_t)f->get_position();
1222
1223 //internal resources
1224 uint32_t int_resources_size = f->get_32();
1225 fw->store_32(int_resources_size);
1226
1227 for (uint32_t i = 0; i < int_resources_size; i++) {
1228
1229 String path = get_ustring(f);
1230 uint64_t offset = f->get_64();
1231 save_ustring(fw, path);
1232 fw->store_64(offset + size_diff);
1233 }
1234
1235 //rest of file
1236 uint8_t b = f->get_8();
1237 while (!f->eof_reached()) {
1238 fw->store_8(b);
1239 b = f->get_8();
1240 }
1241
1242 bool all_ok = fw->get_error() == OK;
1243
1244 fw->seek(md_ofs);
1245 fw->store_64(importmd_ofs + size_diff);
1246
1247 memdelete(f);
1248 memdelete(fw);
1249
1250 if (!all_ok) {
1251 return ERR_CANT_CREATE;
1252 }
1253
1254 DirAccess *da = DirAccess::create(DirAccess::ACCESS_RESOURCES);
1255 da->remove(p_path);
1256 da->rename(p_path + ".depren", p_path);
1257 memdelete(da);
1258 return OK;
1259 }
1260
get_resource_type(const String & p_path) const1261 String ResourceFormatLoaderBinary::get_resource_type(const String &p_path) const {
1262
1263 FileAccess *f = FileAccess::open(p_path, FileAccess::READ);
1264 if (!f) {
1265 return ""; //could not rwead
1266 }
1267
1268 Ref<ResourceInteractiveLoaderBinary> ria = memnew(ResourceInteractiveLoaderBinary);
1269 ria->local_path = ProjectSettings::get_singleton()->localize_path(p_path);
1270 ria->res_path = ria->local_path;
1271 //ria->set_local_path( Globals::get_singleton()->localize_path(p_path) );
1272 String r = ria->recognize(f);
1273 return r;
1274 }
1275
1276 ///////////////////////////////////////////////////////////
1277 ///////////////////////////////////////////////////////////
1278 ///////////////////////////////////////////////////////////
1279
_pad_buffer(FileAccess * f,int p_bytes)1280 void ResourceFormatSaverBinaryInstance::_pad_buffer(FileAccess *f, int p_bytes) {
1281
1282 int extra = 4 - (p_bytes % 4);
1283 if (extra < 4) {
1284 for (int i = 0; i < extra; i++)
1285 f->store_8(0); //pad to 32
1286 }
1287 }
1288
_write_variant(const Variant & p_property,const PropertyInfo & p_hint)1289 void ResourceFormatSaverBinaryInstance::_write_variant(const Variant &p_property, const PropertyInfo &p_hint) {
1290
1291 write_variant(f, p_property, resource_set, external_resources, string_map, p_hint);
1292 }
1293
write_variant(FileAccess * f,const Variant & p_property,Set<RES> & resource_set,Map<RES,int> & external_resources,Map<StringName,int> & string_map,const PropertyInfo & p_hint)1294 void ResourceFormatSaverBinaryInstance::write_variant(FileAccess *f, const Variant &p_property, Set<RES> &resource_set, Map<RES, int> &external_resources, Map<StringName, int> &string_map, const PropertyInfo &p_hint) {
1295
1296 switch (p_property.get_type()) {
1297
1298 case Variant::NIL: {
1299
1300 f->store_32(VARIANT_NIL);
1301 // don't store anything
1302 } break;
1303 case Variant::BOOL: {
1304
1305 f->store_32(VARIANT_BOOL);
1306 bool val = p_property;
1307 f->store_32(val);
1308 } break;
1309 case Variant::INT: {
1310
1311 int64_t val = p_property;
1312 if (val > 0x7FFFFFFF || val < -(int64_t)0x80000000) {
1313 f->store_32(VARIANT_INT64);
1314 f->store_64(val);
1315
1316 } else {
1317 f->store_32(VARIANT_INT);
1318 f->store_32(int32_t(p_property));
1319 }
1320
1321 } break;
1322 case Variant::REAL: {
1323
1324 double d = p_property;
1325 float fl = d;
1326 if (double(fl) != d) {
1327 f->store_32(VARIANT_DOUBLE);
1328 f->store_double(d);
1329 } else {
1330
1331 f->store_32(VARIANT_REAL);
1332 f->store_real(fl);
1333 }
1334
1335 } break;
1336 case Variant::STRING: {
1337
1338 f->store_32(VARIANT_STRING);
1339 String val = p_property;
1340 save_unicode_string(f, val);
1341
1342 } break;
1343 case Variant::VECTOR2: {
1344
1345 f->store_32(VARIANT_VECTOR2);
1346 Vector2 val = p_property;
1347 f->store_real(val.x);
1348 f->store_real(val.y);
1349
1350 } break;
1351 case Variant::RECT2: {
1352
1353 f->store_32(VARIANT_RECT2);
1354 Rect2 val = p_property;
1355 f->store_real(val.position.x);
1356 f->store_real(val.position.y);
1357 f->store_real(val.size.x);
1358 f->store_real(val.size.y);
1359
1360 } break;
1361 case Variant::VECTOR3: {
1362
1363 f->store_32(VARIANT_VECTOR3);
1364 Vector3 val = p_property;
1365 f->store_real(val.x);
1366 f->store_real(val.y);
1367 f->store_real(val.z);
1368
1369 } break;
1370 case Variant::PLANE: {
1371
1372 f->store_32(VARIANT_PLANE);
1373 Plane val = p_property;
1374 f->store_real(val.normal.x);
1375 f->store_real(val.normal.y);
1376 f->store_real(val.normal.z);
1377 f->store_real(val.d);
1378
1379 } break;
1380 case Variant::QUAT: {
1381
1382 f->store_32(VARIANT_QUAT);
1383 Quat val = p_property;
1384 f->store_real(val.x);
1385 f->store_real(val.y);
1386 f->store_real(val.z);
1387 f->store_real(val.w);
1388
1389 } break;
1390 case Variant::AABB: {
1391
1392 f->store_32(VARIANT_AABB);
1393 AABB val = p_property;
1394 f->store_real(val.position.x);
1395 f->store_real(val.position.y);
1396 f->store_real(val.position.z);
1397 f->store_real(val.size.x);
1398 f->store_real(val.size.y);
1399 f->store_real(val.size.z);
1400
1401 } break;
1402 case Variant::TRANSFORM2D: {
1403
1404 f->store_32(VARIANT_MATRIX32);
1405 Transform2D val = p_property;
1406 f->store_real(val.elements[0].x);
1407 f->store_real(val.elements[0].y);
1408 f->store_real(val.elements[1].x);
1409 f->store_real(val.elements[1].y);
1410 f->store_real(val.elements[2].x);
1411 f->store_real(val.elements[2].y);
1412
1413 } break;
1414 case Variant::BASIS: {
1415
1416 f->store_32(VARIANT_MATRIX3);
1417 Basis val = p_property;
1418 f->store_real(val.elements[0].x);
1419 f->store_real(val.elements[0].y);
1420 f->store_real(val.elements[0].z);
1421 f->store_real(val.elements[1].x);
1422 f->store_real(val.elements[1].y);
1423 f->store_real(val.elements[1].z);
1424 f->store_real(val.elements[2].x);
1425 f->store_real(val.elements[2].y);
1426 f->store_real(val.elements[2].z);
1427
1428 } break;
1429 case Variant::TRANSFORM: {
1430
1431 f->store_32(VARIANT_TRANSFORM);
1432 Transform val = p_property;
1433 f->store_real(val.basis.elements[0].x);
1434 f->store_real(val.basis.elements[0].y);
1435 f->store_real(val.basis.elements[0].z);
1436 f->store_real(val.basis.elements[1].x);
1437 f->store_real(val.basis.elements[1].y);
1438 f->store_real(val.basis.elements[1].z);
1439 f->store_real(val.basis.elements[2].x);
1440 f->store_real(val.basis.elements[2].y);
1441 f->store_real(val.basis.elements[2].z);
1442 f->store_real(val.origin.x);
1443 f->store_real(val.origin.y);
1444 f->store_real(val.origin.z);
1445
1446 } break;
1447 case Variant::COLOR: {
1448
1449 f->store_32(VARIANT_COLOR);
1450 Color val = p_property;
1451 f->store_real(val.r);
1452 f->store_real(val.g);
1453 f->store_real(val.b);
1454 f->store_real(val.a);
1455
1456 } break;
1457
1458 case Variant::NODE_PATH: {
1459 f->store_32(VARIANT_NODE_PATH);
1460 NodePath np = p_property;
1461 f->store_16(np.get_name_count());
1462 uint16_t snc = np.get_subname_count();
1463 if (np.is_absolute())
1464 snc |= 0x8000;
1465 f->store_16(snc);
1466 for (int i = 0; i < np.get_name_count(); i++) {
1467 if (string_map.has(np.get_name(i))) {
1468 f->store_32(string_map[np.get_name(i)]);
1469 } else {
1470 save_unicode_string(f, np.get_name(i), true);
1471 }
1472 }
1473 for (int i = 0; i < np.get_subname_count(); i++) {
1474 if (string_map.has(np.get_subname(i))) {
1475 f->store_32(string_map[np.get_subname(i)]);
1476 } else {
1477 save_unicode_string(f, np.get_subname(i), true);
1478 }
1479 }
1480
1481 } break;
1482 case Variant::_RID: {
1483
1484 f->store_32(VARIANT_RID);
1485 WARN_PRINT("Can't save RIDs.");
1486 RID val = p_property;
1487 f->store_32(val.get_id());
1488 } break;
1489 case Variant::OBJECT: {
1490
1491 f->store_32(VARIANT_OBJECT);
1492 RES res = p_property;
1493 if (res.is_null()) {
1494 f->store_32(OBJECT_EMPTY);
1495 return; // don't save it
1496 }
1497
1498 if (res->get_path().length() && res->get_path().find("::") == -1) {
1499 f->store_32(OBJECT_EXTERNAL_RESOURCE_INDEX);
1500 f->store_32(external_resources[res]);
1501 } else {
1502
1503 if (!resource_set.has(res)) {
1504 f->store_32(OBJECT_EMPTY);
1505 ERR_FAIL_MSG("Resource was not pre cached for the resource section, most likely due to circular reference.");
1506 }
1507
1508 f->store_32(OBJECT_INTERNAL_RESOURCE);
1509 f->store_32(res->get_subindex());
1510 //internal resource
1511 }
1512
1513 } break;
1514 case Variant::DICTIONARY: {
1515
1516 f->store_32(VARIANT_DICTIONARY);
1517 Dictionary d = p_property;
1518 f->store_32(uint32_t(d.size()));
1519
1520 List<Variant> keys;
1521 d.get_key_list(&keys);
1522
1523 for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
1524
1525 /*
1526 if (!_check_type(dict[E->get()]))
1527 continue;
1528 */
1529
1530 write_variant(f, E->get(), resource_set, external_resources, string_map);
1531 write_variant(f, d[E->get()], resource_set, external_resources, string_map);
1532 }
1533
1534 } break;
1535 case Variant::ARRAY: {
1536
1537 f->store_32(VARIANT_ARRAY);
1538 Array a = p_property;
1539 f->store_32(uint32_t(a.size()));
1540 for (int i = 0; i < a.size(); i++) {
1541
1542 write_variant(f, a[i], resource_set, external_resources, string_map);
1543 }
1544
1545 } break;
1546 case Variant::POOL_BYTE_ARRAY: {
1547
1548 f->store_32(VARIANT_RAW_ARRAY);
1549 PoolVector<uint8_t> arr = p_property;
1550 int len = arr.size();
1551 f->store_32(len);
1552 PoolVector<uint8_t>::Read r = arr.read();
1553 f->store_buffer(r.ptr(), len);
1554 _pad_buffer(f, len);
1555
1556 } break;
1557 case Variant::POOL_INT_ARRAY: {
1558
1559 f->store_32(VARIANT_INT_ARRAY);
1560 PoolVector<int> arr = p_property;
1561 int len = arr.size();
1562 f->store_32(len);
1563 PoolVector<int>::Read r = arr.read();
1564 for (int i = 0; i < len; i++)
1565 f->store_32(r[i]);
1566
1567 } break;
1568 case Variant::POOL_REAL_ARRAY: {
1569
1570 f->store_32(VARIANT_REAL_ARRAY);
1571 PoolVector<real_t> arr = p_property;
1572 int len = arr.size();
1573 f->store_32(len);
1574 PoolVector<real_t>::Read r = arr.read();
1575 for (int i = 0; i < len; i++) {
1576 f->store_real(r[i]);
1577 }
1578
1579 } break;
1580 case Variant::POOL_STRING_ARRAY: {
1581
1582 f->store_32(VARIANT_STRING_ARRAY);
1583 PoolVector<String> arr = p_property;
1584 int len = arr.size();
1585 f->store_32(len);
1586 PoolVector<String>::Read r = arr.read();
1587 for (int i = 0; i < len; i++) {
1588 save_unicode_string(f, r[i]);
1589 }
1590
1591 } break;
1592 case Variant::POOL_VECTOR3_ARRAY: {
1593
1594 f->store_32(VARIANT_VECTOR3_ARRAY);
1595 PoolVector<Vector3> arr = p_property;
1596 int len = arr.size();
1597 f->store_32(len);
1598 PoolVector<Vector3>::Read r = arr.read();
1599 for (int i = 0; i < len; i++) {
1600 f->store_real(r[i].x);
1601 f->store_real(r[i].y);
1602 f->store_real(r[i].z);
1603 }
1604
1605 } break;
1606 case Variant::POOL_VECTOR2_ARRAY: {
1607
1608 f->store_32(VARIANT_VECTOR2_ARRAY);
1609 PoolVector<Vector2> arr = p_property;
1610 int len = arr.size();
1611 f->store_32(len);
1612 PoolVector<Vector2>::Read r = arr.read();
1613 for (int i = 0; i < len; i++) {
1614 f->store_real(r[i].x);
1615 f->store_real(r[i].y);
1616 }
1617
1618 } break;
1619 case Variant::POOL_COLOR_ARRAY: {
1620
1621 f->store_32(VARIANT_COLOR_ARRAY);
1622 PoolVector<Color> arr = p_property;
1623 int len = arr.size();
1624 f->store_32(len);
1625 PoolVector<Color>::Read r = arr.read();
1626 for (int i = 0; i < len; i++) {
1627 f->store_real(r[i].r);
1628 f->store_real(r[i].g);
1629 f->store_real(r[i].b);
1630 f->store_real(r[i].a);
1631 }
1632
1633 } break;
1634 default: {
1635
1636 ERR_FAIL_MSG("Invalid variant.");
1637 }
1638 }
1639 }
1640
_find_resources(const Variant & p_variant,bool p_main)1641 void ResourceFormatSaverBinaryInstance::_find_resources(const Variant &p_variant, bool p_main) {
1642
1643 switch (p_variant.get_type()) {
1644 case Variant::OBJECT: {
1645
1646 RES res = p_variant.operator RefPtr();
1647
1648 if (res.is_null() || external_resources.has(res))
1649 return;
1650
1651 if (!p_main && (!bundle_resources) && res->get_path().length() && res->get_path().find("::") == -1) {
1652 if (res->get_path() == path) {
1653 ERR_PRINTS("Circular reference to resource being saved found: '" + local_path + "' will be null next time it's loaded.");
1654 return;
1655 }
1656 int idx = external_resources.size();
1657 external_resources[res] = idx;
1658 return;
1659 }
1660
1661 if (resource_set.has(res))
1662 return;
1663
1664 List<PropertyInfo> property_list;
1665
1666 res->get_property_list(&property_list);
1667
1668 for (List<PropertyInfo>::Element *E = property_list.front(); E; E = E->next()) {
1669
1670 if (E->get().usage & PROPERTY_USAGE_STORAGE) {
1671
1672 Variant value = res->get(E->get().name);
1673 if (E->get().usage & PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT) {
1674 RES sres = value;
1675 if (sres.is_valid()) {
1676 NonPersistentKey npk;
1677 npk.base = res;
1678 npk.property = E->get().name;
1679 non_persistent_map[npk] = sres;
1680 resource_set.insert(sres);
1681 saved_resources.push_back(sres);
1682 }
1683 } else {
1684 _find_resources(value);
1685 }
1686 }
1687 }
1688
1689 resource_set.insert(res);
1690 saved_resources.push_back(res);
1691
1692 } break;
1693
1694 case Variant::ARRAY: {
1695
1696 Array varray = p_variant;
1697 int len = varray.size();
1698 for (int i = 0; i < len; i++) {
1699
1700 const Variant &v = varray.get(i);
1701 _find_resources(v);
1702 }
1703
1704 } break;
1705
1706 case Variant::DICTIONARY: {
1707
1708 Dictionary d = p_variant;
1709 List<Variant> keys;
1710 d.get_key_list(&keys);
1711 for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
1712
1713 _find_resources(E->get());
1714 Variant v = d[E->get()];
1715 _find_resources(v);
1716 }
1717 } break;
1718 case Variant::NODE_PATH: {
1719 //take the chance and save node path strings
1720 NodePath np = p_variant;
1721 for (int i = 0; i < np.get_name_count(); i++)
1722 get_string_index(np.get_name(i));
1723 for (int i = 0; i < np.get_subname_count(); i++)
1724 get_string_index(np.get_subname(i));
1725
1726 } break;
1727 default: {
1728 }
1729 }
1730 }
1731
save_unicode_string(FileAccess * f,const String & p_string,bool p_bit_on_len)1732 void ResourceFormatSaverBinaryInstance::save_unicode_string(FileAccess *f, const String &p_string, bool p_bit_on_len) {
1733
1734 CharString utf8 = p_string.utf8();
1735 if (p_bit_on_len) {
1736 f->store_32((utf8.length() + 1) | 0x80000000);
1737 } else {
1738 f->store_32(utf8.length() + 1);
1739 }
1740 f->store_buffer((const uint8_t *)utf8.get_data(), utf8.length() + 1);
1741 }
1742
get_string_index(const String & p_string)1743 int ResourceFormatSaverBinaryInstance::get_string_index(const String &p_string) {
1744
1745 StringName s = p_string;
1746 if (string_map.has(s))
1747 return string_map[s];
1748
1749 string_map[s] = strings.size();
1750 strings.push_back(s);
1751 return strings.size() - 1;
1752 }
1753
save(const String & p_path,const RES & p_resource,uint32_t p_flags)1754 Error ResourceFormatSaverBinaryInstance::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
1755
1756 Error err;
1757 if (p_flags & ResourceSaver::FLAG_COMPRESS) {
1758 FileAccessCompressed *fac = memnew(FileAccessCompressed);
1759 fac->configure("RSCC");
1760 f = fac;
1761 err = fac->_open(p_path, FileAccess::WRITE);
1762 if (err)
1763 memdelete(f);
1764
1765 } else {
1766 f = FileAccess::open(p_path, FileAccess::WRITE, &err);
1767 }
1768
1769 ERR_FAIL_COND_V_MSG(err != OK, err, "Cannot create file '" + p_path + "'.");
1770
1771 relative_paths = p_flags & ResourceSaver::FLAG_RELATIVE_PATHS;
1772 skip_editor = p_flags & ResourceSaver::FLAG_OMIT_EDITOR_PROPERTIES;
1773 bundle_resources = p_flags & ResourceSaver::FLAG_BUNDLE_RESOURCES;
1774 big_endian = p_flags & ResourceSaver::FLAG_SAVE_BIG_ENDIAN;
1775 takeover_paths = p_flags & ResourceSaver::FLAG_REPLACE_SUBRESOURCE_PATHS;
1776
1777 if (!p_path.begins_with("res://"))
1778 takeover_paths = false;
1779
1780 local_path = p_path.get_base_dir();
1781 path = ProjectSettings::get_singleton()->localize_path(p_path);
1782
1783 _find_resources(p_resource, true);
1784
1785 if (!(p_flags & ResourceSaver::FLAG_COMPRESS)) {
1786 //save header compressed
1787 static const uint8_t header[4] = { 'R', 'S', 'R', 'C' };
1788 f->store_buffer(header, 4);
1789 }
1790
1791 if (big_endian) {
1792 f->store_32(1);
1793 f->set_endian_swap(true);
1794 } else
1795 f->store_32(0);
1796
1797 f->store_32(0); //64 bits file, false for now
1798 f->store_32(VERSION_MAJOR);
1799 f->store_32(VERSION_MINOR);
1800 f->store_32(FORMAT_VERSION);
1801
1802 if (f->get_error() != OK && f->get_error() != ERR_FILE_EOF) {
1803 f->close();
1804 memdelete(f);
1805 return ERR_CANT_CREATE;
1806 }
1807
1808 save_unicode_string(f, p_resource->get_class());
1809 f->store_64(0); //offset to import metadata
1810 for (int i = 0; i < 14; i++)
1811 f->store_32(0); // reserved
1812
1813 List<ResourceData> resources;
1814
1815 {
1816
1817 for (List<RES>::Element *E = saved_resources.front(); E; E = E->next()) {
1818
1819 ResourceData &rd = resources.push_back(ResourceData())->get();
1820 rd.type = E->get()->get_class();
1821
1822 List<PropertyInfo> property_list;
1823 E->get()->get_property_list(&property_list);
1824
1825 for (List<PropertyInfo>::Element *F = property_list.front(); F; F = F->next()) {
1826
1827 if (skip_editor && F->get().name.begins_with("__editor"))
1828 continue;
1829 if ((F->get().usage & PROPERTY_USAGE_STORAGE)) {
1830 Property p;
1831 p.name_idx = get_string_index(F->get().name);
1832
1833 if (F->get().usage & PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT) {
1834 NonPersistentKey npk;
1835 npk.base = E->get();
1836 npk.property = F->get().name;
1837 if (non_persistent_map.has(npk)) {
1838 p.value = non_persistent_map[npk];
1839 }
1840 } else {
1841 p.value = E->get()->get(F->get().name);
1842 }
1843
1844 Variant default_value = ClassDB::class_get_default_property_value(E->get()->get_class(), F->get().name);
1845
1846 if (default_value.get_type() != Variant::NIL && bool(Variant::evaluate(Variant::OP_EQUAL, p.value, default_value))) {
1847 continue;
1848 }
1849
1850 p.pi = F->get();
1851
1852 rd.properties.push_back(p);
1853 }
1854 }
1855 }
1856 }
1857
1858 f->store_32(strings.size()); //string table size
1859 for (int i = 0; i < strings.size(); i++) {
1860 save_unicode_string(f, strings[i]);
1861 }
1862
1863 // save external resource table
1864 f->store_32(external_resources.size()); //amount of external resources
1865 Vector<RES> save_order;
1866 save_order.resize(external_resources.size());
1867
1868 for (Map<RES, int>::Element *E = external_resources.front(); E; E = E->next()) {
1869 save_order.write[E->get()] = E->key();
1870 }
1871
1872 for (int i = 0; i < save_order.size(); i++) {
1873
1874 save_unicode_string(f, save_order[i]->get_save_class());
1875 String path = save_order[i]->get_path();
1876 path = relative_paths ? local_path.path_to_file(path) : path;
1877 save_unicode_string(f, path);
1878 }
1879 // save internal resource table
1880 f->store_32(saved_resources.size()); //amount of internal resources
1881 Vector<uint64_t> ofs_pos;
1882 Set<int> used_indices;
1883
1884 for (List<RES>::Element *E = saved_resources.front(); E; E = E->next()) {
1885
1886 RES r = E->get();
1887 if (r->get_path() == "" || r->get_path().find("::") != -1) {
1888
1889 if (r->get_subindex() != 0) {
1890 if (used_indices.has(r->get_subindex())) {
1891 r->set_subindex(0); //repeated
1892 } else {
1893 used_indices.insert(r->get_subindex());
1894 }
1895 }
1896 }
1897 }
1898
1899 for (List<RES>::Element *E = saved_resources.front(); E; E = E->next()) {
1900
1901 RES r = E->get();
1902 if (r->get_path() == "" || r->get_path().find("::") != -1) {
1903 if (r->get_subindex() == 0) {
1904 int new_subindex = 1;
1905 if (used_indices.size()) {
1906 new_subindex = used_indices.back()->get() + 1;
1907 }
1908
1909 r->set_subindex(new_subindex);
1910 used_indices.insert(new_subindex);
1911 }
1912
1913 save_unicode_string(f, "local://" + itos(r->get_subindex()));
1914 if (takeover_paths) {
1915 r->set_path(p_path + "::" + itos(r->get_subindex()), true);
1916 }
1917 #ifdef TOOLS_ENABLED
1918 r->set_edited(false);
1919 #endif
1920 } else {
1921 save_unicode_string(f, r->get_path()); //actual external
1922 }
1923 ofs_pos.push_back(f->get_position());
1924 f->store_64(0); //offset in 64 bits
1925 }
1926
1927 Vector<uint64_t> ofs_table;
1928
1929 //now actually save the resources
1930 for (List<ResourceData>::Element *E = resources.front(); E; E = E->next()) {
1931
1932 ResourceData &rd = E->get();
1933
1934 ofs_table.push_back(f->get_position());
1935 save_unicode_string(f, rd.type);
1936 f->store_32(rd.properties.size());
1937
1938 for (List<Property>::Element *F = rd.properties.front(); F; F = F->next()) {
1939
1940 Property &p = F->get();
1941 f->store_32(p.name_idx);
1942 _write_variant(p.value, F->get().pi);
1943 }
1944 }
1945
1946 for (int i = 0; i < ofs_table.size(); i++) {
1947 f->seek(ofs_pos[i]);
1948 f->store_64(ofs_table[i]);
1949 }
1950
1951 f->seek_end();
1952
1953 f->store_buffer((const uint8_t *)"RSRC", 4); //magic at end
1954
1955 if (f->get_error() != OK && f->get_error() != ERR_FILE_EOF) {
1956 f->close();
1957 memdelete(f);
1958 return ERR_CANT_CREATE;
1959 }
1960
1961 f->close();
1962 memdelete(f);
1963
1964 return OK;
1965 }
1966
save(const String & p_path,const RES & p_resource,uint32_t p_flags)1967 Error ResourceFormatSaverBinary::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
1968
1969 String local_path = ProjectSettings::get_singleton()->localize_path(p_path);
1970 ResourceFormatSaverBinaryInstance saver;
1971 return saver.save(local_path, p_resource, p_flags);
1972 }
1973
recognize(const RES & p_resource) const1974 bool ResourceFormatSaverBinary::recognize(const RES &p_resource) const {
1975
1976 return true; //all recognized
1977 }
1978
get_recognized_extensions(const RES & p_resource,List<String> * p_extensions) const1979 void ResourceFormatSaverBinary::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
1980
1981 String base = p_resource->get_base_extension().to_lower();
1982 p_extensions->push_back(base);
1983 if (base != "res")
1984 p_extensions->push_back("res");
1985 }
1986
1987 ResourceFormatSaverBinary *ResourceFormatSaverBinary::singleton = NULL;
1988
ResourceFormatSaverBinary()1989 ResourceFormatSaverBinary::ResourceFormatSaverBinary() {
1990
1991 singleton = this;
1992 }
1993