text: /*************************************************************************/
  /*  resource_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 "version.h"
  #include "resource_format_binary.h"
  #include "globals.h"
  #include "io/file_access_compressed.h"
  #include "io/marshalls.h"
  //#define print_bl(m_what) print_line(m_what)
  #define print_bl(m_what)
  
  
  enum {
  
  	//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_LOSSLESS=2,
  	IMAGE_ENCODING_LOSSY=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_PVRTC2=12,
  	IMAGE_FORMAT_PVRTC2_ALPHA=13,
  	IMAGE_FORMAT_PVRTC4=14,
  	IMAGE_FORMAT_PVRTC4_ALPHA=15,
  	IMAGE_FORMAT_ETC=16,
  	IMAGE_FORMAT_CUSTOM=30,
  
  
  	OBJECT_EMPTY=0,
  	OBJECT_EXTERNAL_RESOURCE=1,
  	OBJECT_INTERNAL_RESOURCE=2,
  	FORMAT_VERSION=0
  
  
  };
  
  
  void ResourceInteractiveLoaderBinary::_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 ResourceInteractiveLoaderBinary::parse_variant(Variant& r_v)  {
  
  
  	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;
  			} else 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_PVRTC2: { fmt=Image::FORMAT_PVRTC2; } break;
  					case IMAGE_FORMAT_PVRTC2_ALPHA: { fmt=Image::FORMAT_PVRTC2_ALPHA; } break;
  					case IMAGE_FORMAT_PVRTC4: { fmt=Image::FORMAT_PVRTC4; } break;
  					case IMAGE_FORMAT_PVRTC4_ALPHA: { fmt=Image::FORMAT_PVRTC4_ALPHA; } break;
  					case IMAGE_FORMAT_ETC: { fmt=Image::FORMAT_ETC; } break;
  					case IMAGE_FORMAT_CUSTOM: { fmt=Image::FORMAT_CUSTOM; } break;
  					default: {
  
  						ERR_FAIL_V(ERR_FILE_CORRUPT);
  					}
  
  				}
  
  
  				uint32_t datalen = f->get_32();
  
  				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);
  
  			} else {
  				//compressed
  				DVector<uint8_t> data;
  				data.resize(f->get_32());
  				DVector<uint8_t>::Write w = data.write();
  				f->get_buffer(w.ptr(),data.size());
  				w = DVector<uint8_t>::Write();
  
  				Image img;
  
  				if (encoding==IMAGE_ENCODING_LOSSY && Image::lossy_unpacker) {
  
  					img = Image::lossy_unpacker(data);
  				} else if (encoding==IMAGE_ENCODING_LOSSLESS && Image::lossless_unpacker) {
  
  					img = Image::lossless_unpacker(data);
  				}
  				_advance_padding(data.size());
  
  
  				r_v=img;
  
  			}
  
  		} break;
  		case VARIANT_NODE_PATH: {
  
  			Vector<StringName> names;
  			Vector<StringName> subnames;
  			StringName property;
  			bool absolute;
  
  			int name_count = f->get_16();
  			uint32_t subname_count = f->get_16();
  			absolute=subname_count&0x8000;
  			subname_count&=0x7FFF;
  
  
  			for(int i=0;i<name_count;i++)
  				names.push_back(string_map[f->get_32()]);
  			for(uint32_t i=0;i<subname_count;i++)
  				subnames.push_back(string_map[f->get_32()]);
  			property=string_map[f->get_32()];
  
  			NodePath np = NodePath(names,subnames,absolute,property);
  			//print_line("got path: "+String(np));
  
  			r_v=np;
  
  		} 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 = res_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(res_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: {
  
              uint32_t len=f->get_32();
              Dictionary d(len&0x80000000); //last bit means shared
              len&=0x7FFFFFFF;
              for(uint32_t i=0;i<len;i++) {
  				Variant key;
  				Error err = parse_variant(key);
  				ERR_FAIL_COND_V(err,ERR_FILE_CORRUPT);
  				Variant value;
  				err = parse_variant(value);
  				ERR_FAIL_COND_V(err,ERR_FILE_CORRUPT);
  				d[key]=value;
  			}
  			r_v=d;
  		} break;
  		case VARIANT_ARRAY: {
  
              uint32_t len=f->get_32();
              Array a(len&0x80000000); //last bit means shared
              len&=0x7FFFFFFF;
  			a.resize(len);
              for(uint32_t i=0;i<len;i++) {
  				Variant val;
  				Error err = parse_variant(val);
  				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);
  #ifdef BIG_ENDIAN_ENABLED
  			{
  				uint32_t *ptr=(uint32_t*)w.ptr();
  				for(int i=0;i<len;i++) {
  
  					ptr[i]=BSWAP32(ptr[i]);
  				}
  			}
  
  #endif
  			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));
  #ifdef BIG_ENDIAN_ENABLED
  			{
  				uint32_t *ptr=(uint32_t*)w.ptr();
  				for(int i=0;i<len;i++) {
  
  					ptr[i]=BSWAP32(ptr[i]);
  				}
  			}
  
  #endif
  
  			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(uint32_t 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);
  #ifdef BIG_ENDIAN_ENABLED
  			{
  				uint32_t *ptr=(uint32_t*)w.ptr();
  				for(int i=0;i<len*2;i++) {
  
  					ptr[i]=BSWAP32(ptr[i]);
  				}
  			}
  
  #endif
  
  			} 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);
  #ifdef BIG_ENDIAN_ENABLED
  				{
  					uint32_t *ptr=(uint32_t*)w.ptr();
  					for(int i=0;i<len*3;i++) {
  
  						ptr[i]=BSWAP32(ptr[i]);
  					}
  				}
  
  #endif
  
  			} 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);
  #ifdef BIG_ENDIAN_ENABLED
  			{
  				uint32_t *ptr=(uint32_t*)w.ptr();
  				for(int i=0;i<len*4;i++) {
  
  					ptr[i]=BSWAP32(ptr[i]);
  				}
  			}
  
  #endif
  
  			} 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
  
  }
  
  
  void ResourceInteractiveLoaderBinary::set_local_path(const String& p_local_path) {
  
  	res_path=p_local_path;
  }
  
  Ref<Resource> ResourceInteractiveLoaderBinary::get_resource(){
  
  
  	return resource;
  }
  Error ResourceInteractiveLoaderBinary::poll(){
  
  	if (error!=OK)
  		return error;
  
  
  	int s = stage;
  
  	if (s<external_resources.size()) {
  
  		RES res = ResourceLoader::load(external_resources[s].path,external_resources[s].type);
  		if (res.is_null()) {
  
  			if (!ResourceLoader::get_abort_on_missing_resources()) {
  
  				ResourceLoader::notify_load_error("Resource Not Found: "+external_resources[s].path);
  			} else {
  
  
  				error=ERR_FILE_CORRUPT;
  				ERR_EXPLAIN("Can't load dependency: "+external_resources[s].path);
  				ERR_FAIL_V(error);
  			}
  
  		} else {
  			resource_cache.push_back(res);
  		}
  
  		stage++;
  		return OK;
  	}
  
  	s-=external_resources.size();
  
  
  	if (s>=internal_resources.size()) {
  
  		error=ERR_BUG;
  		ERR_FAIL_COND_V(s>=internal_resources.size(),error);
  	}
  
  	bool main = s==(internal_resources.size()-1);
  
  	//maybe it is loaded already
  	String path;
  
  
  
  	if (!main) {
  
  		path=internal_resources[s].path;
  		if (path.begins_with("local://"))
  			path=path.replace("local://",res_path+"::");
  
  
  
  		if (ResourceCache::has(path)) {
  			//already loaded, don't do anything
  			stage++;
  			error=OK;
  			return error;
  		}
  	} else {
  
  		path=res_path;
  	}
  
  	uint64_t offset = internal_resources[s].offset;
  
  	f->seek(offset);
  
  	String t = get_unicode_string();
  
  	Object *obj = ObjectTypeDB::instance(t);
  	if (!obj) {
  		error=ERR_FILE_CORRUPT;
  		ERR_EXPLAIN(local_path+":Resource of unrecognized type in file: "+t);
  	}
  	ERR_FAIL_COND_V(!obj,ERR_FILE_CORRUPT);
  
  	Resource *r = obj->cast_to<Resource>();
  	if (!r) {
  		error=ERR_FILE_CORRUPT;
  		memdelete(obj); //bye
  		ERR_EXPLAIN(local_path+":Resoucre type in resource field not a resource, type is: "+obj->get_type());
  		ERR_FAIL_COND_V(!r,ERR_FILE_CORRUPT);
  	}
  
  	RES res = RES( r );
  
  	r->set_path(path);
  
  	int pc = f->get_32();
  
  	//set properties
  
  	for(int i=0;i<pc;i++) {
  
  		uint32_t name_idx = f->get_32();
  		if (name_idx>=(uint32_t)string_map.size()) {
  			error=ERR_FILE_CORRUPT;
  			ERR_FAIL_V(ERR_FILE_CORRUPT);
  		}
  
  		Variant value;
  
  		error = parse_variant(value);
  		if (error)
  			return error;
  
  		res->set(string_map[name_idx],value);
  	}
  #ifdef TOOLS_ENABLED
  	res->set_edited(false);
  #endif
  	stage++;
  
  	resource_cache.push_back(res);
  
  	if (main) {
  		if (importmd_ofs) {
  
  			f->seek(importmd_ofs);
  			Ref<ResourceImportMetadata> imd = memnew( ResourceImportMetadata );
  			imd->set_editor(get_unicode_string());
  			int sc = f->get_32();
  			for(int i=0;i<sc;i++) {
  
  				String src = get_unicode_string();
  				String md5 = get_unicode_string();
  				imd->add_source(src,md5);
  			}
  			int pc = f->get_32();
  
  			for(int i=0;i<pc;i++) {
  
  				String name = get_unicode_string();
  				Variant val;
  				parse_variant(val);
  				imd->set_option(name,val);
  			}
  			res->set_import_metadata(imd);
  
  		}
  		f->close();
  		resource=res;
  		error=ERR_FILE_EOF;
  
  	} else {
  		error=OK;
  	}
  
  	return OK;
  
  }
  int ResourceInteractiveLoaderBinary::get_stage() const{
  
  	return stage;
  }
  int ResourceInteractiveLoaderBinary::get_stage_count() const {
  
  	return external_resources.size()+internal_resources.size();
  }
  
  String ResourceInteractiveLoaderBinary::get_unicode_string() {
  
  	int 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;
  }
  
  
  
  void ResourceInteractiveLoaderBinary::get_dependencies(FileAccess *p_f,List<String> *p_dependencies) {
  
  	open(p_f);
  	if (error)
  		return;
  
  	for(int i=0;i<external_resources.size();i++) {
  
  		p_dependencies->push_back(external_resources[i].path);
  	}
  
  }
  
  
  
  
  void ResourceInteractiveLoaderBinary::open(FileAccess *p_f) {
  
  
  	error=OK;
  
  	f=p_f;
  	uint8_t header[4];
  	f->get_buffer(header,4);
  	if (header[0]=='R' && header[1]=='S' && header[2]=='C' && header[3]=='C') {
  		//compressed
  		FileAccessCompressed *fac = memnew( FileAccessCompressed );
  		fac->open_after_magic(f);
  		f=fac;
  
  	} else if (header[0]!='R' || header[1]!='S' || header[2]!='R' || header[3]!='C') {
  		//not normal
  
  		error=ERR_FILE_UNRECOGNIZED;
  		ERR_EXPLAIN("Unrecognized binary resource file: "+local_path);
  		ERR_FAIL_V();
  	}
  
  	bool big_endian = f->get_32();
  #ifdef BIG_ENDIAN_ENABLED
  	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();
  	uint32_t ver_format=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));
  	print_bl("format: "+itos(ver_format));
  
  	if (ver_format<FORMAT_VERSION ||  ver_major>VERSION_MAJOR || (ver_major==VERSION_MAJOR && ver_minor>VERSION_MINOR)) {
  
  		f->close();
  		ERR_EXPLAIN("File Format '"+itos(FORMAT_VERSION)+"."+itos(ver_major)+"."+itos(ver_minor)+"' is too new! Please upgrade to a a new engine version: "+local_path);
  		ERR_FAIL();
  
  	}
  
  	type=get_unicode_string();
  
  	print_bl("type: "+type);
  
  	importmd_ofs = f->get_64();
  	for(int i=0;i<14;i++)
  		f->get_32(); //skip a few reserved fields
  
  	uint32_t string_table_size=f->get_32();
  	string_map.resize(string_table_size);
  	for(uint32_t i=0;i<string_table_size;i++) {
  
  		StringName s = get_unicode_string();
  		string_map[i]=s;
  	}
  
  	print_bl("strings: "+itos(string_table_size));
  
  	uint32_t ext_resources_size=f->get_32();
  	for(uint32_t i=0;i<ext_resources_size;i++) {
  
  		ExtResoucre er;
  		er.type=get_unicode_string();
  		er.path=get_unicode_string();
  		external_resources.push_back(er);
  
  	}
  
  	print_bl("ext resources: "+itos(ext_resources_size));
  	uint32_t int_resources_size=f->get_32();
  
  	for(uint32_t i=0;i<int_resources_size;i++) {
  
  		IntResoucre ir;
  		ir.path=get_unicode_string();
  		ir.offset=f->get_64();
  		internal_resources.push_back(ir);
  	}
  
  	print_bl("int resources: "+itos(int_resources_size));
  
  
  	if (f->eof_reached()) {
  
  		error=ERR_FILE_CORRUPT;
  		ERR_EXPLAIN("Premature End Of File: "+local_path);
  		ERR_FAIL();
  	}
  
  }
  
  String ResourceInteractiveLoaderBinary::recognize(FileAccess *p_f) {
  
  	error=OK;
  
  
  	f=p_f;
  	uint8_t header[4];
  	f->get_buffer(header,4);
  	if (header[0]=='R' && header[1]=='S' && header[2]=='C' && header[3]=='C') {
  		//compressed
  		FileAccessCompressed *fac = memnew( FileAccessCompressed );
  		fac->open_after_magic(f);
  		f=fac;
  
  	} else if (header[0]!='R' || header[1]!='S' || header[2]!='R' || header[3]!='C') {
  		//not normal
  		return "";
  	}
  
  	bool big_endian = f->get_32();
  #ifdef BIG_ENDIAN_ENABLED
  	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();
  	uint32_t ver_format=f->get_32();
  
  	if (ver_format<FORMAT_VERSION ||  ver_major>VERSION_MAJOR || (ver_major==VERSION_MAJOR && ver_minor>VERSION_MINOR)) {
  
  		f->close();
  		return "";
  	}
  
  	String type=get_unicode_string();
  
  	return type;
  }
  
  ResourceInteractiveLoaderBinary::ResourceInteractiveLoaderBinary() {
  
  	f=NULL;
  	stage=0;
  	endian_swap=false;
  	use_real64=false;
  	error=OK;
  }
  
  ResourceInteractiveLoaderBinary::~ResourceInteractiveLoaderBinary() {
  
  	if (f)
  		memdelete(f);
  }
  
  
  Ref<ResourceInteractiveLoader> ResourceFormatLoaderBinary::load_interactive(const String &p_path) {
  
  
  	Error err;
  	FileAccess *f = FileAccess::open(p_path,FileAccess::READ,&err);
  
  	if (err!=OK) {
  
  		ERR_FAIL_COND_V(err!=OK,Ref<ResourceInteractiveLoader>());
  	}
  
  	Ref<ResourceInteractiveLoaderBinary> ria = memnew( ResourceInteractiveLoaderBinary );
  	ria->local_path=Globals::get_singleton()->localize_path(p_path);
  	ria->res_path=ria->local_path;
  //	ria->set_local_path( Globals::get_singleton()->localize_path(p_path) );
  	ria->open(f);
  
  
  	return ria;
  }
  
  void ResourceFormatLoaderBinary::get_recognized_extensions_for_type(const String& p_type,List<String> *p_extensions) const {
  
  	if (p_type=="") {
  		get_recognized_extensions(p_extensions);
  		return;
  	}
  
  	List<String> extensions;
  	ObjectTypeDB::get_extensions_for_type(p_type,&extensions);
  
  	extensions.sort();
  
  	for(List<String>::Element *E=extensions.front();E;E=E->next()) {
  		String ext = E->get().to_lower();
  		if (ext=="res")
  			continue;
  //		p_extensions->push_back("x"+ext);
  		p_extensions->push_back(ext);
  	}
  
  	p_extensions->push_back("res");
  
  }
  void ResourceFormatLoaderBinary::get_recognized_extensions(List<String> *p_extensions) const{
  
  	List<String> extensions;
  	ObjectTypeDB::get_resource_base_extensions(&extensions);
  	extensions.sort();
  
  	for(List<String>::Element *E=extensions.front();E;E=E->next()) {
  		String ext = E->get().to_lower();
  		if (ext=="res")
  			continue;
  		p_extensions->push_back(ext);
  	}
  
  	p_extensions->push_back("res");
  }
  
  bool ResourceFormatLoaderBinary::handles_type(const String& p_type) const{
  
  
  	return true; //handles all
  }
  
  Error ResourceFormatLoaderBinary::load_import_metadata(const String &p_path, Ref<ResourceImportMetadata>& r_var) const {
  
  
  	FileAccess *f = FileAccess::open(p_path,FileAccess::READ);
  	if (!f) {
  		return ERR_FILE_CANT_OPEN;
  	}
  
  	Ref<ResourceInteractiveLoaderBinary> ria = memnew( ResourceInteractiveLoaderBinary );
  	ria->local_path=Globals::get_singleton()->localize_path(p_path);
  	ria->res_path=ria->local_path;
  //	ria->set_local_path( Globals::get_singleton()->localize_path(p_path) );
  	ria->recognize(f);
  	if(ria->error!=OK)
  		return ERR_FILE_UNRECOGNIZED;
  	f=ria->f;
  	uint64_t imp_ofs = f->get_64();
  
  	if (imp_ofs==0)
  		return ERR_UNAVAILABLE;
  
  	f->seek(imp_ofs);
  	Ref<ResourceImportMetadata> imd = memnew( ResourceImportMetadata );
  	imd->set_editor(ria->get_unicode_string());
  	int sc = f->get_32();
  	for(int i=0;i<sc;i++) {
  
  		String src = ria->get_unicode_string();
  		String md5 = ria->get_unicode_string();
  		imd->add_source(src,md5);
  	}
  	int pc = f->get_32();
  
  	for(int i=0;i<pc;i++) {
  
  		String name = ria->get_unicode_string();
  		Variant val;
  		ria->parse_variant(val);
  		imd->set_option(name,val);
  	}
  
  	r_var=imd;
  
  	return OK;
  
  }
  
  
  void ResourceFormatLoaderBinary::get_dependencies(const String& p_path,List<String> *p_dependencies) {
  
  	FileAccess *f = FileAccess::open(p_path,FileAccess::READ);
  	ERR_FAIL_COND(!f);
  
  	Ref<ResourceInteractiveLoaderBinary> ria = memnew( ResourceInteractiveLoaderBinary );
  	ria->local_path=Globals::get_singleton()->localize_path(p_path);
  	ria->res_path=ria->local_path;
  //	ria->set_local_path( Globals::get_singleton()->localize_path(p_path) );
  	ria->get_dependencies(f,p_dependencies);
  }
  
  
  String ResourceFormatLoaderBinary::get_resource_type(const String &p_path) const {
  
  	FileAccess *f = FileAccess::open(p_path,FileAccess::READ);
  	if (!f) {
  		return ""; //could not rwead
  	}
  
  	Ref<ResourceInteractiveLoaderBinary> ria = memnew( ResourceInteractiveLoaderBinary );
  	ria->local_path=Globals::get_singleton()->localize_path(p_path);
  	ria->res_path=ria->local_path;
  //	ria->set_local_path( Globals::get_singleton()->localize_path(p_path) );
  	String r = ria->recognize(f);
  	return r;
  
  
  }
  
  
  
  ///////////////////////////////////////////////////////////
  ///////////////////////////////////////////////////////////
  ///////////////////////////////////////////////////////////
  
  
  void ResourceFormatSaverBinaryInstance::_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 ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property,const PropertyInfo& p_hint) {
  
  	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;
  			}
  
  			int encoding=IMAGE_ENCODING_RAW;
  			float quality=0.7;
  
  			if (val.get_format() <= Image::FORMAT_INDEXED_ALPHA) {
  				//can only compress uncompressed stuff
  
  				if (p_hint.hint==PROPERTY_HINT_IMAGE_COMPRESS_LOSSY && Image::lossy_packer) {
  					encoding=IMAGE_ENCODING_LOSSY;
  					float qs=p_hint.hint_string.to_double();
  					if (qs!=0.0)
  						quality=qs;
  
  				} else if (p_hint.hint==PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS && Image::lossless_packer) {
  					encoding=IMAGE_ENCODING_LOSSLESS;
  
  				}
  			}
  
  			f->store_32(encoding); //raw encoding
  
  			if (encoding==IMAGE_ENCODING_RAW) {
  
  
  				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_PVRTC2: f->store_32(IMAGE_FORMAT_PVRTC2 ); break;
  					case Image::FORMAT_PVRTC2_ALPHA: f->store_32(IMAGE_FORMAT_PVRTC2_ALPHA ); break;
  					case Image::FORMAT_PVRTC4: f->store_32(IMAGE_FORMAT_PVRTC4 ); break;
  					case Image::FORMAT_PVRTC4_ALPHA: f->store_32(IMAGE_FORMAT_PVRTC4_ALPHA ); break;
  					case Image::FORMAT_ETC: f->store_32(IMAGE_FORMAT_ETC); break;
  					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);
  			} else {
  
  				DVector<uint8_t> data;
  				if (encoding==IMAGE_ENCODING_LOSSY) {
  					data=Image::lossy_packer(val,quality);
  
  				} else if (encoding==IMAGE_ENCODING_LOSSLESS) {
  					data=Image::lossless_packer(val);
  
  				}
  
  				int ds=data.size();
  				f->store_32(ds);
  				if (ds>0) {
  					DVector<uint8_t>::Read r = data.read();
  					f->store_buffer(r.ptr(),ds);
  
  					_pad_buffer(ds);
  
  				}
  			}
  
  		} break;
  		case Variant::NODE_PATH: {
  			f->store_32(VARIANT_NODE_PATH);
  			NodePath np=p_property;
  			f->store_16(np.get_name_count());
  			uint16_t snc = np.get_subname_count();
  			if (np.is_absolute())
  				snc|=0x8000;
  			f->store_16(snc);
  			for(int i=0;i<np.get_name_count();i++)
  				f->store_32(get_string_index(np.get_name(i)));
  			for(int i=0;i<np.get_subname_count();i++)
  				f->store_32(get_string_index(np.get_subname(i)));
  			f->store_32(get_string_index(np.get_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_save_type());
  				String path=relative_paths?local_path.path_to_file(res->get_path()):res->get_path();
  				if (no_extensions)
  					path=path.basename()+".*";
  				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(uint32_t(d.size())|(d.is_shared()?0x80000000:0));
  
  			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_variant(E->get());
  				write_variant(d[E->get()]);
  			}
  
  
  		} break;
  		case Variant::ARRAY: {
  
  			f->store_32(VARIANT_ARRAY);
  			Array a=p_property;
  			f->store_32(uint32_t(a.size())|(a.is_shared()?0x80000000:0));
  			for(int i=0;i<a.size();i++) {
  
  				write_variant(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 ResourceFormatSaverBinaryInstance::_find_resources(const Variant& p_variant,bool p_main) {
  
  
  	switch(p_variant.get_type()) {
  		case Variant::OBJECT: {
  
  
  			RES res = p_variant.operator RefPtr();
  
  			if (res.is_null())
  				return;
  
  			if (!p_main && (!bundle_resources ) && res->get_path().length() && res->get_path().find("::") == -1 ) {
  				external_resources.insert(res);
  				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));
  				}
  			}
  
  			resource_map[ res ] = saved_resources.size();
  			saved_resources.push_back(res);
  
  		} 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()) {
  
  				_find_resources(E->get());
  				Variant v = d[E->get()];
  				_find_resources(v);
  			}
  		} break;
  		case Variant::NODE_PATH: {
  			//take the chance and save node path strings
  			NodePath np = p_variant;
  			for(int i=0;i<np.get_name_count();i++)
  				get_string_index(np.get_name(i));
  			for(int i=0;i<np.get_subname_count();i++)
  				get_string_index(np.get_subname(i));
  			get_string_index(np.get_property());
  
  
  		} break;
  
  		default: {}
  	}
  
  }
  #if 0
  Error ResourceFormatSaverBinary::_save_obj(const Object *p_object,SavedObject *so) {
  
  	//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 ResourceFormatSaverBinary::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;
  }
  #endif
  
  void ResourceFormatSaverBinaryInstance::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);
  }
  
  int ResourceFormatSaverBinaryInstance::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;
  }
  
  
  Error ResourceFormatSaverBinaryInstance::save(const String &p_path,const RES& p_resource,uint32_t p_flags) {
  
  	Error err;
  	if (p_flags&ResourceSaver::FLAG_COMPRESS) {
  		FileAccessCompressed *fac = memnew( FileAccessCompressed );
  		fac->configure("RSCC");
  		f=fac;
  		err = fac->_open(p_path,FileAccess::WRITE);
  		if (err)
  			memdelete(f);
  
  	} else {
  		f=FileAccess::open(p_path,FileAccess::WRITE,&err);
  	}
  
  
  	ERR_FAIL_COND_V(err,err);
  	FileAccessRef _fref(f);
  
  
  	relative_paths=p_flags&ResourceSaver::FLAG_RELATIVE_PATHS;
  	skip_editor=p_flags&ResourceSaver::FLAG_OMIT_EDITOR_PROPERTIES;
  	bundle_resources=p_flags&ResourceSaver::FLAG_BUNDLE_RESOURCES;
  	big_endian=p_flags&ResourceSaver::FLAG_SAVE_BIG_ENDIAN;
  	no_extensions=p_flags&ResourceSaver::FLAG_NO_EXTENSION;
  
  	local_path=p_path.get_base_dir();
  	//bin_meta_idx = get_string_index("__bin_meta__"); //is often used, so create
  
  	_find_resources(p_resource,true);
  
  	if (!(p_flags&ResourceSaver::FLAG_COMPRESS)) {
  		//save header compressed
  		static const uint8_t header[4]={'R','S','R','C'};
  		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);
  	f->store_32(FORMAT_VERSION);
  
  	//f->store_32(saved_resources.size()+external_resources.size()); // load steps -not needed
  	save_unicode_string(p_resource->get_type());
  	uint64_t md_at = f->get_pos();
  	f->store_64(0); //offset to impoty metadata
  	for(int i=0;i<14;i++)
  		f->store_32(0); // reserved
  
  
  	List<ResourceData> resources;
  
  
  	{
  
  
  		for(List<RES>::Element *E=saved_resources.front();E;E=E->next()) {
  
  
  			ResourceData &rd = resources.push_back(ResourceData())->get();
  			rd.type=E->get()->get_type();
  
  			List<PropertyInfo> property_list;
  			E->get()->get_property_list( &property_list );
  
  			for(List<PropertyInfo>::Element *F=property_list.front();F;F=F->next()) {
  
  				if (skip_editor && F->get().name.begins_with("__editor"))
  					continue;
  				if (F->get().usage&PROPERTY_USAGE_STORAGE || (bundle_resources && F->get().usage&PROPERTY_USAGE_BUNDLE)) {
  					Property p;
  					p.name_idx=get_string_index(F->get().name);
  					p.value=E->get()->get(F->get().name);
  					if (F->get().usage&PROPERTY_USAGE_STORE_IF_NONZERO && p.value.is_zero())
  						continue;
  					p.pi=F->get();										
  
  					rd.properties.push_back(p);
  
  				}
  			}
  
  
  
  		}
  	}
  
  
  	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 external resource table
  	f->store_32(external_resources.size()); //amount of external resources
  	for(Set<RES>::Element *E=external_resources.front();E;E=E->next()) {
  
  		save_unicode_string(E->get()->get_save_type());
  		String path = E->get()->get_path();
  		if (no_extensions)
  			path=path.basename()+".*";
  		save_unicode_string(path);
  	}
  	// save internal resource table
  	f->store_32(saved_resources.size()); //amount of internal resources
  	Vector<uint64_t> ofs_pos;
  	for(List<RES>::Element *E=saved_resources.front();E;E=E->next()) {
  
  		RES r = E->get();
  		if (r->get_path()=="" || r->get_path().find("::")!=-1)
  			save_unicode_string("local://"+itos(ofs_pos.size()));
  		else
  			save_unicode_string(r->get_path()); //actual external
  		ofs_pos.push_back(f->get_pos());
  		f->store_64(0); //offset in 64 bits
  	}
  
  	Vector<uint64_t> ofs_table;
  //	int saved_idx=0;
  	//now actually save the resources
  
  	for(List<ResourceData>::Element *E=resources.front();E;E=E->next()) {
  
  		ResourceData & rd = E->get();
  
  		ofs_table.push_back(f->get_pos());
  		save_unicode_string(rd.type);
  		f->store_32(rd.properties.size());
  
  		for (List<Property>::Element *F=rd.properties.front();F;F=F->next()) {
  
  			Property &p=F->get();
  			f->store_32(p.name_idx);
  			write_variant(p.value,F->get().pi);
  		}
  
  	}
  
  	for(int i=0;i<ofs_table.size();i++) {
  		f->seek(ofs_pos[i]);
  		f->store_64(ofs_table[i]);
  	}
  
  	f->seek_end();
  	if (p_resource->get_import_metadata().is_valid()) {
  		uint64_t md_pos = f->get_pos();
  		Ref<ResourceImportMetadata> imd=p_resource->get_import_metadata();
  		save_unicode_string(imd->get_editor());
  		f->store_32(imd->get_source_count());
  		for(int i=0;i<imd->get_source_count();i++) {
  			save_unicode_string(imd->get_source_path(i));
  			save_unicode_string(imd->get_source_md5(i));
  		}
  		List<String> options;
  		imd->get_options(&options);
  		f->store_32(options.size());
  		for(List<String>::Element *E=options.front();E;E=E->next()) {
  			save_unicode_string(E->get());
  			write_variant(imd->get_option(E->get()));
  		}
  
  		f->seek(md_at);
  		f->store_64(md_pos);
  		f->seek_end();
  	}
  
  
  	f->store_buffer((const uint8_t*)"RSRC",4); //magic at end
  
  	f->close();
  
  
  	return OK;
  }
  
  
  
  Error ResourceFormatSaverBinary::save(const String &p_path,const RES& p_resource,uint32_t p_flags) {
  
  
  	String local_path = Globals::get_singleton()->localize_path(p_path);
  	ResourceFormatSaverBinaryInstance saver;
  	return saver.save(local_path,p_resource,p_flags);
  
  }
  
  
  bool ResourceFormatSaverBinary::recognize(const RES& p_resource) const {
  
  	return true; //all recognized
  
  }
  
  void ResourceFormatSaverBinary::get_recognized_extensions(const RES& p_resource,List<String> *p_extensions) const {
  
  
  	//here comes the sun, lalalala
  	String base = p_resource->get_base_extension().to_lower();
  	if (base!="res") {
  
  		p_extensions->push_back(base);
  	}
  
  	p_extensions->push_back("res");
  
  
  }
  
  