godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/core/io/object_format_binary.cpp

1492 lines
35 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* object_format_binary.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "object_format_binary.h"
#include "resource.h"
#include "io/resource_loader.h"
#include "print_string.h"
#include "object_type_db.h"
#include "globals.h"
#include "os/os.h"
#include "version.h"
#define print_bl(m_what)
#ifdef OLD_SCENE_FORMAT_ENABLED
enum {
SECTION_RESOURCE=0,
SECTION_OBJECT=1,
SECTION_META_OBJECT=2,
SECTION_PROPERTY=3,
SECTION_END=4,
//numbering must be different from variant, in case new variant types are added (variant must be always contiguous for jumptable optimization)
VARIANT_NIL=1,
VARIANT_BOOL=2,
VARIANT_INT=3,
VARIANT_REAL=4,
VARIANT_STRING=5,
VARIANT_VECTOR2=10,
VARIANT_RECT2=11,
VARIANT_VECTOR3=12,
VARIANT_PLANE=13,
VARIANT_QUAT=14,
VARIANT_AABB=15,
VARIANT_MATRIX3=16,
VARIANT_TRANSFORM=17,
VARIANT_MATRIX32=18,
VARIANT_COLOR=20,
VARIANT_IMAGE=21,
VARIANT_NODE_PATH=22,
VARIANT_RID=23,
VARIANT_OBJECT=24,
VARIANT_INPUT_EVENT=25,
VARIANT_DICTIONARY=26,
VARIANT_ARRAY=30,
VARIANT_RAW_ARRAY=31,
VARIANT_INT_ARRAY=32,
VARIANT_REAL_ARRAY=33,
VARIANT_STRING_ARRAY=34,
VARIANT_VECTOR3_ARRAY=35,
VARIANT_COLOR_ARRAY=36,
VARIANT_VECTOR2_ARRAY=37,
IMAGE_ENCODING_EMPTY=0,
IMAGE_ENCODING_RAW=1,
IMAGE_ENCODING_PNG=2, //not yet
IMAGE_ENCODING_JPG=3,
IMAGE_FORMAT_GRAYSCALE=0,
IMAGE_FORMAT_INTENSITY=1,
IMAGE_FORMAT_GRAYSCALE_ALPHA=2,
IMAGE_FORMAT_RGB=3,
IMAGE_FORMAT_RGBA=4,
IMAGE_FORMAT_INDEXED=5,
IMAGE_FORMAT_INDEXED_ALPHA=6,
IMAGE_FORMAT_BC1=7,
IMAGE_FORMAT_BC2=8,
IMAGE_FORMAT_BC3=9,
IMAGE_FORMAT_BC4=10,
IMAGE_FORMAT_BC5=11,
IMAGE_FORMAT_CUSTOM=12,
OBJECT_EMPTY=0,
OBJECT_EXTERNAL_RESOURCE=1,
OBJECT_INTERNAL_RESOURCE=2,
};
void ObjectFormatSaverBinary::_pad_buffer(int p_bytes) {
int extra = 4-(p_bytes%4);
if (extra<4) {
for(int i=0;i<extra;i++)
f->store_8(0); //pad to 32
}
}
void ObjectFormatSaverBinary::write_property(int p_idx,const Variant& p_property) {
f->store_32(SECTION_PROPERTY);
f->store_32(p_idx);
switch(p_property.get_type()) {
case Variant::NIL: {
f->store_32(VARIANT_NIL);
// don't store anything
} break;
case Variant::BOOL: {
f->store_32(VARIANT_BOOL);
bool val=p_property;
f->store_32(val);
} break;
case Variant::INT: {
f->store_32(VARIANT_INT);
int val=p_property;
f->store_32(val);
} break;
case Variant::REAL: {
f->store_32(VARIANT_REAL);
real_t val=p_property;
f->store_real(val);
} break;
case Variant::STRING: {
f->store_32(VARIANT_STRING);
String val=p_property;
save_unicode_string(val);
} break;
case Variant::VECTOR2: {
f->store_32(VARIANT_VECTOR2);
Vector2 val=p_property;
f->store_real(val.x);
f->store_real(val.y);
} break;
case Variant::RECT2: {
f->store_32(VARIANT_RECT2);
Rect2 val=p_property;
f->store_real(val.pos.x);
f->store_real(val.pos.y);
f->store_real(val.size.x);
f->store_real(val.size.y);
} break;
case Variant::VECTOR3: {
f->store_32(VARIANT_VECTOR3);
Vector3 val=p_property;
f->store_real(val.x);
f->store_real(val.y);
f->store_real(val.z);
} break;
case Variant::PLANE: {
f->store_32(VARIANT_PLANE);
Plane val=p_property;
f->store_real(val.normal.x);
f->store_real(val.normal.y);
f->store_real(val.normal.z);
f->store_real(val.d);
} break;
case Variant::QUAT: {
f->store_32(VARIANT_QUAT);
Quat val=p_property;
f->store_real(val.x);
f->store_real(val.y);
f->store_real(val.z);
f->store_real(val.w);
} break;
case Variant::_AABB: {
f->store_32(VARIANT_AABB);
AABB val=p_property;
f->store_real(val.pos.x);
f->store_real(val.pos.y);
f->store_real(val.pos.z);
f->store_real(val.size.x);
f->store_real(val.size.y);
f->store_real(val.size.z);
} break;
case Variant::MATRIX32: {
f->store_32(VARIANT_MATRIX32);
Matrix32 val=p_property;
f->store_real(val.elements[0].x);
f->store_real(val.elements[0].y);
f->store_real(val.elements[1].x);
f->store_real(val.elements[1].y);
f->store_real(val.elements[2].x);
f->store_real(val.elements[2].y);
} break;
case Variant::MATRIX3: {
f->store_32(VARIANT_MATRIX3);
Matrix3 val=p_property;
f->store_real(val.elements[0].x);
f->store_real(val.elements[0].y);
f->store_real(val.elements[0].z);
f->store_real(val.elements[1].x);
f->store_real(val.elements[1].y);
f->store_real(val.elements[1].z);
f->store_real(val.elements[2].x);
f->store_real(val.elements[2].y);
f->store_real(val.elements[2].z);
} break;
case Variant::TRANSFORM: {
f->store_32(VARIANT_TRANSFORM);
Transform val=p_property;
f->store_real(val.basis.elements[0].x);
f->store_real(val.basis.elements[0].y);
f->store_real(val.basis.elements[0].z);
f->store_real(val.basis.elements[1].x);
f->store_real(val.basis.elements[1].y);
f->store_real(val.basis.elements[1].z);
f->store_real(val.basis.elements[2].x);
f->store_real(val.basis.elements[2].y);
f->store_real(val.basis.elements[2].z);
f->store_real(val.origin.x);
f->store_real(val.origin.y);
f->store_real(val.origin.z);
} break;
case Variant::COLOR: {
f->store_32(VARIANT_COLOR);
Color val=p_property;
f->store_real(val.r);
f->store_real(val.g);
f->store_real(val.b);
f->store_real(val.a);
} break;
case Variant::IMAGE: {
f->store_32(VARIANT_IMAGE);
Image val =p_property;
if (val.empty()) {
f->store_32(IMAGE_ENCODING_EMPTY);
break;
}
f->store_32(IMAGE_ENCODING_RAW); //raw encoding
f->store_32(val.get_width());
f->store_32(val.get_height());
f->store_32(val.get_mipmaps());
switch(val.get_format()) {
case Image::FORMAT_GRAYSCALE: f->store_32(IMAGE_FORMAT_GRAYSCALE ); break; ///< one byte per pixel: f->store_32(IMAGE_FORMAT_ ); break; 0-255
case Image::FORMAT_INTENSITY: f->store_32(IMAGE_FORMAT_INTENSITY ); break; ///< one byte per pixel: f->store_32(IMAGE_FORMAT_ ); break; 0-255
case Image::FORMAT_GRAYSCALE_ALPHA: f->store_32(IMAGE_FORMAT_GRAYSCALE_ALPHA ); break; ///< two bytes per pixel: f->store_32(IMAGE_FORMAT_ ); break; 0-255. alpha 0-255
case Image::FORMAT_RGB: f->store_32(IMAGE_FORMAT_RGB ); break; ///< one byte R: f->store_32(IMAGE_FORMAT_ ); break; one byte G: f->store_32(IMAGE_FORMAT_ ); break; one byte B
case Image::FORMAT_RGBA: f->store_32(IMAGE_FORMAT_RGBA ); break; ///< one byte R: f->store_32(IMAGE_FORMAT_ ); break; one byte G: f->store_32(IMAGE_FORMAT_ ); break; one byte B: f->store_32(IMAGE_FORMAT_ ); break; one byte A
case Image::FORMAT_INDEXED: f->store_32(IMAGE_FORMAT_INDEXED ); break; ///< index byte 0-256: f->store_32(IMAGE_FORMAT_ ); break; and after image end: f->store_32(IMAGE_FORMAT_ ); break; 256*3 bytes of palette
case Image::FORMAT_INDEXED_ALPHA: f->store_32(IMAGE_FORMAT_INDEXED_ALPHA ); break; ///< index byte 0-256: f->store_32(IMAGE_FORMAT_ ); break; and after image end: f->store_32(IMAGE_FORMAT_ ); break; 256*4 bytes of palette (alpha)
case Image::FORMAT_BC1: f->store_32(IMAGE_FORMAT_BC1 ); break; // DXT1
case Image::FORMAT_BC2: f->store_32(IMAGE_FORMAT_BC2 ); break; // DXT3
case Image::FORMAT_BC3: f->store_32(IMAGE_FORMAT_BC3 ); break; // DXT5
case Image::FORMAT_BC4: f->store_32(IMAGE_FORMAT_BC4 ); break; // ATI1
case Image::FORMAT_BC5: f->store_32(IMAGE_FORMAT_BC5 ); break; // ATI2
case Image::FORMAT_CUSTOM: f->store_32(IMAGE_FORMAT_CUSTOM ); break;
default: {}
}
int dlen = val.get_data().size();
f->store_32(dlen);
DVector<uint8_t>::Read r = val.get_data().read();
f->store_buffer(r.ptr(),dlen);
_pad_buffer(dlen);
} break;
case Variant::NODE_PATH: {
f->store_32(VARIANT_NODE_PATH);
save_unicode_string(p_property);
} break;
case Variant::_RID: {
f->store_32(VARIANT_RID);
WARN_PRINT("Can't save RIDs");
RID val = p_property;
f->store_32(val.get_id());
} break;
case Variant::OBJECT: {
f->store_32(VARIANT_OBJECT);
RES res = p_property;
if (res.is_null()) {
f->store_32(OBJECT_EMPTY);
return; // don't save it
}
if (res->get_path().length() && res->get_path().find("::")==-1) {
f->store_32(OBJECT_EXTERNAL_RESOURCE);
save_unicode_string(res->get_type());
String path=relative_paths?local_path.path_to_file(res->get_path()):res->get_path();
save_unicode_string(path);
} else {
if (!resource_map.has(res)) {
f->store_32(OBJECT_EMPTY);
ERR_EXPLAIN("Resource was not pre cached for the resource section, bug?");
ERR_FAIL();
}
f->store_32(OBJECT_INTERNAL_RESOURCE);
f->store_32(resource_map[res]);
//internal resource
}
} break;
case Variant::INPUT_EVENT: {
f->store_32(VARIANT_INPUT_EVENT);
WARN_PRINT("Can't save InputEvent (maybe it could..)");
} break;
case Variant::DICTIONARY: {
f->store_32(VARIANT_DICTIONARY);
Dictionary d = p_property;
f->store_32(d.size());
List<Variant> keys;
d.get_key_list(&keys);
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
//if (!_check_type(dict[E->get()]))
// continue;
write_property(0,E->get());
write_property(0,d[E->get()]);
}
} break;
case Variant::ARRAY: {
f->store_32(VARIANT_ARRAY);
Array a=p_property;
f->store_32(a.size());
for(int i=0;i<a.size();i++) {
write_property(i,a[i]);
}
} break;
case Variant::RAW_ARRAY: {
f->store_32(VARIANT_RAW_ARRAY);
DVector<uint8_t> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<uint8_t>::Read r = arr.read();
f->store_buffer(r.ptr(),len);
_pad_buffer(len);
} break;
case Variant::INT_ARRAY: {
f->store_32(VARIANT_INT_ARRAY);
DVector<int> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<int>::Read r = arr.read();
for(int i=0;i<len;i++)
f->store_32(r[i]);
} break;
case Variant::REAL_ARRAY: {
f->store_32(VARIANT_REAL_ARRAY);
DVector<real_t> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<real_t>::Read r = arr.read();
for(int i=0;i<len;i++) {
f->store_real(r[i]);
}
} break;
case Variant::STRING_ARRAY: {
f->store_32(VARIANT_STRING_ARRAY);
DVector<String> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<String>::Read r = arr.read();
for(int i=0;i<len;i++) {
save_unicode_string(r[i]);
}
} break;
case Variant::VECTOR3_ARRAY: {
f->store_32(VARIANT_VECTOR3_ARRAY);
DVector<Vector3> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<Vector3>::Read r = arr.read();
for(int i=0;i<len;i++) {
f->store_real(r[i].x);
f->store_real(r[i].y);
f->store_real(r[i].z);
}
} break;
case Variant::VECTOR2_ARRAY: {
f->store_32(VARIANT_VECTOR2_ARRAY);
DVector<Vector2> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<Vector2>::Read r = arr.read();
for(int i=0;i<len;i++) {
f->store_real(r[i].x);
f->store_real(r[i].y);
}
} break;
case Variant::COLOR_ARRAY: {
f->store_32(VARIANT_COLOR_ARRAY);
DVector<Color> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<Color>::Read r = arr.read();
for(int i=0;i<len;i++) {
f->store_real(r[i].r);
f->store_real(r[i].g);
f->store_real(r[i].b);
f->store_real(r[i].a);
}
} break;
default: {
ERR_EXPLAIN("Invalid variant");
ERR_FAIL();
}
}
}
void ObjectFormatSaverBinary::_find_resources(const Variant& p_variant) {
switch(p_variant.get_type()) {
case Variant::OBJECT: {
RES res = p_variant.operator RefPtr();
if (res.is_null())
return;
if (!bundle_resources && res->get_path().length() && res->get_path().find("::") == -1 )
return;
if (resource_map.has(res))
return;
List<PropertyInfo> property_list;
res->get_property_list(&property_list);
for(List<PropertyInfo>::Element *E=property_list.front();E;E=E->next()) {
if (E->get().usage&PROPERTY_USAGE_STORAGE || (bundle_resources && E->get().usage&PROPERTY_USAGE_BUNDLE)) {
_find_resources(res->get(E->get().name));
}
}
SavedObject *so = memnew( SavedObject );
_save_obj(res.ptr(),so);
so->meta=res.get_ref_ptr();
resource_map[ res ] = saved_resources.size();
saved_resources.push_back(so);
} break;
case Variant::ARRAY: {
Array varray=p_variant;
int len=varray.size();
for(int i=0;i<len;i++) {
Variant v=varray.get(i);
_find_resources(v);
}
} break;
case Variant::DICTIONARY: {
Dictionary d=p_variant;
List<Variant> keys;
d.get_key_list(&keys);
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
Variant v = d[E->get()];
_find_resources(v);
}
} break;
default: {}
}
}
Error ObjectFormatSaverBinary::_save_obj(const Object *p_object,SavedObject *so) {
if (optimizer.is_valid()) {
//use optimizer
List<OptimizedSaver::Property> props;
optimizer->get_property_list(p_object,&props);
for(List<OptimizedSaver::Property>::Element *E=props.front();E;E=E->next()) {
if (skip_editor && String(E->get().name).begins_with("__editor"))
continue;
_find_resources(E->get().value);
SavedObject::SavedProperty sp;
sp.name_idx=get_string_index(E->get().name);
sp.value=E->get().value;
so->properties.push_back(sp);
}
} else {
//use classic way
List<PropertyInfo> property_list;
p_object->get_property_list( &property_list );
for(List<PropertyInfo>::Element *E=property_list.front();E;E=E->next()) {
if (skip_editor && E->get().name.begins_with("__editor"))
continue;
if (E->get().usage&PROPERTY_USAGE_STORAGE || (bundle_resources && E->get().usage&PROPERTY_USAGE_BUNDLE)) {
SavedObject::SavedProperty sp;
sp.name_idx=get_string_index(E->get().name);
sp.value = p_object->get(E->get().name);
_find_resources(sp.value);
so->properties.push_back(sp);
}
}
}
return OK;
}
Error ObjectFormatSaverBinary::save(const Object *p_object,const Variant &p_meta) {
ERR_FAIL_COND_V(!f,ERR_UNCONFIGURED);
ERR_EXPLAIN("write_object should supply either an object, a meta, or both");
ERR_FAIL_COND_V(!p_object && p_meta.get_type()==Variant::NIL, ERR_INVALID_PARAMETER);
SavedObject *so = memnew( SavedObject );
if (p_object)
so->type=p_object->get_type();
_find_resources(p_meta);
so->meta=p_meta;
Error err = _save_obj(p_object,so);
ERR_FAIL_COND_V( err, ERR_INVALID_DATA );
saved_objects.push_back(so);
return OK;
}
void ObjectFormatSaverBinary::save_unicode_string(const String& p_string) {
CharString utf8 = p_string.utf8();
f->store_32(utf8.length()+1);
f->store_buffer((const uint8_t*)utf8.get_data(),utf8.length()+1);
}
ObjectFormatSaverBinary::ObjectFormatSaverBinary(FileAccess *p_file,const String& p_magic,const String& p_local_path,uint32_t p_flags,const Ref<OptimizedSaver>& p_optimizer) {
optimizer=p_optimizer;
relative_paths=p_flags&ObjectSaver::FLAG_RELATIVE_PATHS;
skip_editor=p_flags&ObjectSaver::FLAG_OMIT_EDITOR_PROPERTIES;
bundle_resources=p_flags&ObjectSaver::FLAG_BUNDLE_RESOURCES;
big_endian=p_flags&ObjectSaver::FLAG_SAVE_BIG_ENDIAN;
f=p_file; // should be already opened
local_path=p_local_path;
magic=p_magic;
bin_meta_idx = get_string_index("__bin_meta__"); //is often used, so create
}
int ObjectFormatSaverBinary::get_string_index(const String& p_string) {
StringName s=p_string;
if (string_map.has(s))
return string_map[s];
string_map[s]=strings.size();
strings.push_back(s);
return strings.size()-1;
}
ObjectFormatSaverBinary::~ObjectFormatSaverBinary() {
static const uint8_t header[4]={'O','B','D','B'};
f->store_buffer(header,4);
if (big_endian) {
f->store_32(1);
f->set_endian_swap(true);
} else
f->store_32(0);
f->store_32(0); //64 bits file, false for now
f->store_32(VERSION_MAJOR);
f->store_32(VERSION_MINOR);
save_unicode_string(magic);
for(int i=0;i<16;i++)
f->store_32(0); // reserved
f->store_32(strings.size()); //string table size
for(int i=0;i<strings.size();i++) {
print_bl("saving string: "+strings[i]);
save_unicode_string(strings[i]);
}
// save resources
for(int i=0;i<saved_resources.size();i++) {
SavedObject *so = saved_resources[i];
RES res = so->meta;
ERR_CONTINUE(!resource_map.has(res));
f->store_32(SECTION_RESOURCE);
size_t skip_pos = f->get_pos();
f->store_64(0); // resource skip seek pos
save_unicode_string(res->get_type());
if (res->get_path().length() && res->get_path().find("::") == -1 )
save_unicode_string(res->get_path());
else
save_unicode_string("local://"+itos(i));
List<SavedObject::SavedProperty>::Element *SE = so->properties.front();
while(SE) {
write_property(SE->get().name_idx,SE->get().value);
SE=SE->next();
}
f->store_32(SECTION_END);
size_t end=f->get_pos();
f->seek(skip_pos);
f->store_64(end);
f->seek_end();
memdelete( so );
}
if (!saved_objects.empty()) {
for(List<SavedObject*>::Element *E=saved_objects.front();E;E=E->next()) {
SavedObject *so = E->get();
size_t section_end;
if (so->type!="") {
f->store_32(SECTION_OBJECT);
section_end=f->get_pos();
f->store_64(0); //section end
save_unicode_string(so->type);
} else {
f->store_32(SECTION_META_OBJECT);
section_end=f->get_pos();
f->store_64(0); //section end
}
if (so->meta.get_type()!=Variant::NIL)
write_property(bin_meta_idx,so->meta);
List<SavedObject::SavedProperty>::Element *SE = so->properties.front();
while(SE) {
write_property(SE->get().name_idx,SE->get().value);
SE=SE->next();
}
f->store_32(SECTION_END);
size_t end=f->get_pos();
f->seek(section_end);
f->store_64(end);
f->seek_end();
memdelete(so); //no longer needed
}
}
f->store_32(SECTION_END);
f->close();
memdelete(f);
}
ObjectFormatSaver* ObjectFormatSaverInstancerBinary::instance(const String& p_file,const String& p_magic,uint32_t p_flags,const Ref<OptimizedSaver>& p_optimizer) {
FileAccess *f = FileAccess::open(p_file, FileAccess::WRITE);
ERR_FAIL_COND_V( !f, NULL );
String local_path = Globals::get_singleton()->localize_path(p_file);
return memnew( ObjectFormatSaverBinary( f, p_magic,local_path,p_flags,p_optimizer ) );
}
void ObjectFormatSaverInstancerBinary::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back("bin");
}
ObjectFormatSaverInstancerBinary::~ObjectFormatSaverInstancerBinary() {
}
/************************************************/
/************************************************/
/************************************************/
/************************************************/
/************************************************/
void ObjectFormatLoaderBinary::_advance_padding(uint32_t p_len) {
uint32_t extra = 4-(p_len%4);
if (extra<4) {
for(uint32_t i=0;i<extra;i++)
f->get_8(); //pad to 32
}
}
Error ObjectFormatLoaderBinary::parse_property(Variant& r_v, int &r_index) {
uint32_t prop = f->get_32();
if (prop==SECTION_END)
return ERR_FILE_EOF;
ERR_FAIL_COND_V(prop!=SECTION_PROPERTY,ERR_FILE_CORRUPT);
r_index = f->get_32();
uint32_t type = f->get_32();
print_bl("find property of type: "+itos(type));
switch(type) {
case VARIANT_NIL: {
r_v=Variant();
} break;
case VARIANT_BOOL: {
r_v=bool(f->get_32());
} break;
case VARIANT_INT: {
r_v=int(f->get_32());
} break;
case VARIANT_REAL: {
r_v=f->get_real();
} break;
case VARIANT_STRING: {
r_v=get_unicode_string();
} break;
case VARIANT_VECTOR2: {
Vector2 v;
v.x=f->get_real();
v.y=f->get_real();
r_v=v;
} break;
case VARIANT_RECT2: {
Rect2 v;
v.pos.x=f->get_real();
v.pos.y=f->get_real();
v.size.x=f->get_real();
v.size.y=f->get_real();
r_v=v;
} break;
case VARIANT_VECTOR3: {
Vector3 v;
v.x=f->get_real();
v.y=f->get_real();
v.z=f->get_real();
r_v=v;
} break;
case VARIANT_PLANE: {
Plane v;
v.normal.x=f->get_real();
v.normal.y=f->get_real();
v.normal.z=f->get_real();
v.d=f->get_real();
r_v=v;
} break;
case VARIANT_QUAT: {
Quat v;
v.x=f->get_real();
v.y=f->get_real();
v.z=f->get_real();
v.w=f->get_real();
r_v=v;
} break;
case VARIANT_AABB: {
AABB v;
v.pos.x=f->get_real();
v.pos.y=f->get_real();
v.pos.z=f->get_real();
v.size.x=f->get_real();
v.size.y=f->get_real();
v.size.z=f->get_real();
r_v=v;
} break;
case VARIANT_MATRIX32: {
Matrix32 v;
v.elements[0].x=f->get_real();
v.elements[0].y=f->get_real();
v.elements[1].x=f->get_real();
v.elements[1].y=f->get_real();
v.elements[2].x=f->get_real();
v.elements[2].y=f->get_real();
r_v=v;
} break;
case VARIANT_MATRIX3: {
Matrix3 v;
v.elements[0].x=f->get_real();
v.elements[0].y=f->get_real();
v.elements[0].z=f->get_real();
v.elements[1].x=f->get_real();
v.elements[1].y=f->get_real();
v.elements[1].z=f->get_real();
v.elements[2].x=f->get_real();
v.elements[2].y=f->get_real();
v.elements[2].z=f->get_real();
r_v=v;
} break;
case VARIANT_TRANSFORM: {
Transform v;
v.basis.elements[0].x=f->get_real();
v.basis.elements[0].y=f->get_real();
v.basis.elements[0].z=f->get_real();
v.basis.elements[1].x=f->get_real();
v.basis.elements[1].y=f->get_real();
v.basis.elements[1].z=f->get_real();
v.basis.elements[2].x=f->get_real();
v.basis.elements[2].y=f->get_real();
v.basis.elements[2].z=f->get_real();
v.origin.x=f->get_real();
v.origin.y=f->get_real();
v.origin.z=f->get_real();
r_v=v;
} break;
case VARIANT_COLOR: {
Color v;
v.r=f->get_real();
v.g=f->get_real();
v.b=f->get_real();
v.a=f->get_real();
r_v=v;
} break;
case VARIANT_IMAGE: {
uint32_t encoding = f->get_32();
if (encoding==IMAGE_ENCODING_EMPTY) {
r_v=Variant();
break;
}
if (encoding==IMAGE_ENCODING_RAW) {
uint32_t width = f->get_32();
uint32_t height = f->get_32();
uint32_t mipmaps = f->get_32();
uint32_t format = f->get_32();
Image::Format fmt;
switch(format) {
case IMAGE_FORMAT_GRAYSCALE: { fmt=Image::FORMAT_GRAYSCALE; } break;
case IMAGE_FORMAT_INTENSITY: { fmt=Image::FORMAT_INTENSITY; } break;
case IMAGE_FORMAT_GRAYSCALE_ALPHA: { fmt=Image::FORMAT_GRAYSCALE_ALPHA; } break;
case IMAGE_FORMAT_RGB: { fmt=Image::FORMAT_RGB; } break;
case IMAGE_FORMAT_RGBA: { fmt=Image::FORMAT_RGBA; } break;
case IMAGE_FORMAT_INDEXED: { fmt=Image::FORMAT_INDEXED; } break;
case IMAGE_FORMAT_INDEXED_ALPHA: { fmt=Image::FORMAT_INDEXED_ALPHA; } break;
case IMAGE_FORMAT_BC1: { fmt=Image::FORMAT_BC1; } break;
case IMAGE_FORMAT_BC2: { fmt=Image::FORMAT_BC2; } break;
case IMAGE_FORMAT_BC3: { fmt=Image::FORMAT_BC3; } break;
case IMAGE_FORMAT_BC4: { fmt=Image::FORMAT_BC4; } break;
case IMAGE_FORMAT_BC5: { fmt=Image::FORMAT_BC5; } break;
case IMAGE_FORMAT_CUSTOM: { fmt=Image::FORMAT_CUSTOM; } break;
default: {
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
}
uint32_t datalen = f->get_32();
print_bl("width: "+itos(width));
print_bl("height: "+itos(height));
print_bl("mipmaps: "+itos(mipmaps));
print_bl("format: "+itos(format));
print_bl("datalen: "+itos(datalen));
DVector<uint8_t> imgdata;
imgdata.resize(datalen);
DVector<uint8_t>::Write w = imgdata.write();
f->get_buffer(w.ptr(),datalen);
_advance_padding(datalen);
w=DVector<uint8_t>::Write();
r_v=Image(width,height,mipmaps,fmt,imgdata);
}
} break;
case VARIANT_NODE_PATH: {
r_v=NodePath(get_unicode_string());
} break;
case VARIANT_RID: {
r_v=f->get_32();
} break;
case VARIANT_OBJECT: {
uint32_t type=f->get_32();
switch(type) {
case OBJECT_EMPTY: {
//do none
} break;
case OBJECT_INTERNAL_RESOURCE: {
uint32_t index=f->get_32();
String path = local_path+"::"+itos(index);
RES res = ResourceLoader::load(path);
if (res.is_null()) {
WARN_PRINT(String("Couldn't load resource: "+path).utf8().get_data());
}
r_v=res;
} break;
case OBJECT_EXTERNAL_RESOURCE: {
String type = get_unicode_string();
String path = get_unicode_string();
if (path.find("://")==-1 && path.is_rel_path()) {
// path is relative to file being loaded, so convert to a resource path
path=Globals::get_singleton()->localize_path(local_path.get_base_dir()+"/"+path);
}
RES res=ResourceLoader::load(path,type);
if (res.is_null()) {
WARN_PRINT(String("Couldn't load resource: "+path).utf8().get_data());
}
r_v=res;
} break;
default: {
ERR_FAIL_V(ERR_FILE_CORRUPT);
} break;
}
} break;
case VARIANT_INPUT_EVENT: {
} break;
case VARIANT_DICTIONARY: {
int len=f->get_32();
Dictionary d;
for(int i=0;i<len;i++) {
int idx;
Variant key;
Error err = parse_property(key,idx);
ERR_FAIL_COND_V(err,ERR_FILE_CORRUPT);
Variant value;
err = parse_property(value,idx);
ERR_FAIL_COND_V(err,ERR_FILE_CORRUPT);
d[key]=value;
}
r_v=d;
} break;
case VARIANT_ARRAY: {
int len=f->get_32();
Array a;
a.resize(len);
for(int i=0;i<len;i++) {
int idx;
Variant val;
Error err = parse_property(val,idx);
ERR_FAIL_COND_V(err,ERR_FILE_CORRUPT);
a[i]=val;
}
r_v=a;
} break;
case VARIANT_RAW_ARRAY: {
uint32_t len = f->get_32();
DVector<uint8_t> array;
array.resize(len);
DVector<uint8_t>::Write w = array.write();
f->get_buffer(w.ptr(),len);
_advance_padding(len);
w=DVector<uint8_t>::Write();
r_v=array;
} break;
case VARIANT_INT_ARRAY: {
uint32_t len = f->get_32();
DVector<int> array;
array.resize(len);
DVector<int>::Write w = array.write();
f->get_buffer((uint8_t*)w.ptr(),len*4);
w=DVector<int>::Write();
r_v=array;
} break;
case VARIANT_REAL_ARRAY: {
uint32_t len = f->get_32();
DVector<real_t> array;
array.resize(len);
DVector<real_t>::Write w = array.write();
f->get_buffer((uint8_t*)w.ptr(),len*sizeof(real_t));
w=DVector<real_t>::Write();
r_v=array;
} break;
case VARIANT_STRING_ARRAY: {
uint32_t len = f->get_32();
DVector<String> array;
array.resize(len);
DVector<String>::Write w = array.write();
for(int i=0;i<len;i++)
w[i]=get_unicode_string();
w=DVector<String>::Write();
r_v=array;
} break;
case VARIANT_VECTOR2_ARRAY: {
uint32_t len = f->get_32();
DVector<Vector2> array;
array.resize(len);
DVector<Vector2>::Write w = array.write();
if (sizeof(Vector2)==8) {
f->get_buffer((uint8_t*)w.ptr(),len*sizeof(real_t)*2);
} else {
ERR_EXPLAIN("Vector2 size is NOT 8!");
ERR_FAIL_V(ERR_UNAVAILABLE);
}
w=DVector<Vector2>::Write();
r_v=array;
} break;
case VARIANT_VECTOR3_ARRAY: {
uint32_t len = f->get_32();
DVector<Vector3> array;
array.resize(len);
DVector<Vector3>::Write w = array.write();
if (sizeof(Vector3)==12) {
f->get_buffer((uint8_t*)w.ptr(),len*sizeof(real_t)*3);
} else {
ERR_EXPLAIN("Vector3 size is NOT 12!");
ERR_FAIL_V(ERR_UNAVAILABLE);
}
w=DVector<Vector3>::Write();
r_v=array;
} break;
case VARIANT_COLOR_ARRAY: {
uint32_t len = f->get_32();
DVector<Color> array;
array.resize(len);
DVector<Color>::Write w = array.write();
if (sizeof(Color)==16) {
f->get_buffer((uint8_t*)w.ptr(),len*sizeof(real_t)*4);
} else {
ERR_EXPLAIN("Color size is NOT 16!");
ERR_FAIL_V(ERR_UNAVAILABLE);
}
w=DVector<Color>::Write();
r_v=array;
} break;
default: {
ERR_FAIL_V(ERR_FILE_CORRUPT);
} break;
}
return OK; //never reach anyway
}
Error ObjectFormatLoaderBinary::load(Object **p_object,Variant &p_meta) {
while(true) {
if (f->eof_reached()) {
ERR_EXPLAIN("Premature end of file at: "+local_path);
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
RES resource;
Object *obj=NULL;
bool meta=false;
uint32_t section = f->get_32();
switch(section) {
case SECTION_RESOURCE: {
print_bl("resource found");
size_t section_end = f->get_64();
print_bl("section end: "+itos(section_end));
String type = get_unicode_string();
String path = get_unicode_string();
print_bl("path: "+path);
if (path.begins_with("local://")) {
//built-in resource (but really external)
path=path.replace("local://",local_path+"::");
}
if (ResourceCache::has(path)) {
f->seek(section_end);
continue;
}
//load properties
obj = ObjectTypeDB::instance(type);
if (!obj) {
ERR_EXPLAIN("Object of unrecognized type '"+type+"' in file: "+type);
}
ERR_FAIL_COND_V(!obj,ERR_FILE_CORRUPT);
Resource *r = obj->cast_to<Resource>();
if (!r) {
memdelete(obj); //bye
ERR_EXPLAIN("Object type in resource field not a resource, type is: "+obj->get_type());
ERR_FAIL_COND_V(!obj->cast_to<Resource>(),ERR_FILE_CORRUPT);
}
resource = RES( r );
r->set_path(path);
} break;
case SECTION_META_OBJECT:
meta=true;
print_bl("meta found");
case SECTION_OBJECT: {
uint64_t section_end = f->get_64();
if (!meta) {
print_bl("object");
String type = get_unicode_string();
if (ObjectTypeDB::can_instance(type)) {
obj = ObjectTypeDB::instance(type);
if (!obj) {
ERR_EXPLAIN("Object of unrecognized type in file: "+type);
}
ERR_FAIL_COND_V(!obj,ERR_FILE_CORRUPT);
} else {
f->seek(section_end);
return ERR_SKIP;
};
}
} break;
case SECTION_END: {
return ERR_FILE_EOF;
} break;
default: {
ERR_EXPLAIN("Invalid Section ID '"+itos(section)+"' in file: "+local_path);
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
}
//load properties
while(true) {
int name_idx;
Variant v;
Error err;
err = parse_property(v,name_idx);
print_bl("prop idx "+itos(name_idx)+" value: "+String(v));
if (err==ERR_FILE_EOF)
break;
if (err!=OK) {
ERR_EXPLAIN("File Corrupted");
ERR_FAIL_COND_V(err!=OK,ERR_FILE_CORRUPT);
}
if (resource.is_null() && name_idx==0) { //0 is __bin_meta__
p_meta=v;
continue;
} else if (!obj) {
ERR_EXPLAIN("Normal property found in meta object.");
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
Map<int,StringName>::Element *E=string_map.find(name_idx);
if (!E) {
ERR_EXPLAIN("Property ID has no matching name: "+itos(name_idx));
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
obj->set(E->get(),v);
}
if (!obj) {
*p_object=NULL;
return OK; // it was a meta object
}
if (resource.is_null()) {
//regular object
*p_object=obj;
return OK;
} else {
resource_cache.push_back(resource); //keep it in mem until finished loading
}
}
}
ObjectFormatLoaderBinary::~ObjectFormatLoaderBinary() {
if (f) {
if (f->is_open())
f->close();
memdelete(f);
}
}
String ObjectFormatLoaderBinary::get_unicode_string() {
uint32_t len = f->get_32();
if (len>str_buf.size()) {
str_buf.resize(len);
}
f->get_buffer((uint8_t*)&str_buf[0],len);
String s;
s.parse_utf8(&str_buf[0]);
return s;
}
ObjectFormatLoaderBinary::ObjectFormatLoaderBinary(FileAccess *p_f,bool p_endian_swap,bool p_use64) {
f=p_f;
endian_swap=p_endian_swap;
use_real64=p_use64;
//load string table
uint32_t string_table_size = f->get_32();
print_bl("string table size: "+itos(string_table_size));
for(int i=0;i<string_table_size;i++) {
String str = get_unicode_string();
print_bl("string "+itos(i)+" is: "+str);
string_map[i]=str;
}
}
ObjectFormatLoaderBinary* ObjectFormatLoaderInstancerBinary::instance(const String& p_file,const String& p_magic) {
FileAccess *f=FileAccess::open(p_file,FileAccess::READ);
ERR_FAIL_COND_V(!f,NULL);
uint8_t header[4];
f->get_buffer(header,4);
if (header[0]!='O' || header[1]!='B' || header[2]!='D' || header[3]!='B') {
ERR_EXPLAIN("File not in valid binary format: "+p_file);
ERR_FAIL_V(NULL);
}
uint32_t big_endian = f->get_32();
#ifdef BIG_ENDIAN_ENABLED
bool endian_swap = !big_endian;
#else
bool endian_swap = big_endian;
#endif
bool use_real64 = f->get_32();
f->set_endian_swap(big_endian!=0); //read big endian if saved as big endian
uint32_t ver_major=f->get_32();
uint32_t ver_minor=f->get_32();
print_bl("big endian: "+itos(big_endian));
print_bl("endian swap: "+itos(endian_swap));
print_bl("real64: "+itos(use_real64));
print_bl("major: "+itos(ver_major));
print_bl("minor: "+itos(ver_minor));
if (ver_major>VERSION_MAJOR || (ver_major==VERSION_MAJOR && ver_minor>VERSION_MINOR)) {
f->close();
memdelete(f);
ERR_EXPLAIN("File Format '"+itos(ver_major)+"."+itos(ver_minor)+"' is too new! Please upgrade to a a new engine version: "+p_file);
ERR_FAIL_V(NULL);
}
uint32_t magic_len = f->get_32();
Vector<char> magic;
magic.resize(magic_len);
f->get_buffer((uint8_t*)&magic[0],magic_len);
String magic_str;
magic_str.parse_utf8(&magic[0]);
print_bl("magic: "+magic_str);
if (magic_str!=p_magic) {
f->close();
memdelete(f);
ERR_EXPLAIN("File magic mismatch, found '"+magic_str+"' in : "+p_file);
ERR_FAIL_V(NULL);
}
print_bl("skipping 32");
for(int i=0;i<16;i++)
f->get_32(); //skip a few reserved fields
if (f->eof_reached()) {
f->close();
memdelete(f);
ERR_EXPLAIN("Premature End Of File: "+p_file);
ERR_FAIL_V(NULL);
}
print_bl("creating loader");
ObjectFormatLoaderBinary *loader = memnew( ObjectFormatLoaderBinary(f,endian_swap,use_real64) );
loader->local_path=p_file;
return loader;
}
void ObjectFormatLoaderInstancerBinary::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back("bin");
}
#endif