asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/core/io/resource_format_xml.cpp
Juan Linietsky 07e9741425 **WARNING BEFORE PULLING** 
This push changes the binary and XML formats and bumps the major version to 2.0. As such, files saved in this version WILL NO LONGER WORK IN PREVIOUS VERSIONS. This compatibility breakage with older versions was required in order to properly provide project refactoring tools.
If I were you, unless you are brave, I would wait a week or two before pulling, in case of bugs :)

Summary of Changes

-New Filesystem dock, with filesystem & tree view modes.
-New refactoring tools, to change or fix dependencies.
-Quick search dialog, to quickly search any file
2015-08-23 20:15:56 -03:00

2885 lines
65 KiB
C++
Raw Blame History

/*************************************************************************/
/* resource_format_xml.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2015 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 "resource_format_xml.h"
#include "globals.h"
#include "version.h"
#include "os/dir_access.h"
ResourceInteractiveLoaderXML::Tag* ResourceInteractiveLoaderXML::parse_tag(bool *r_exit, bool p_printerr, List<String> *r_order) {
while(get_char()!='<' && !f->eof_reached()) {}
if (f->eof_reached()) {
return NULL;
}
Tag tag;
bool exit=false;
if (r_exit)
*r_exit=false;
bool complete=false;
while(!f->eof_reached()) {
CharType c=get_char();
if (c<33 && tag.name.length() && !exit) {
break;
} else if (c=='>') {
complete=true;
break;
} else if (c=='/') {
exit=true;
} else {
tag.name+=c;
}
}
if (f->eof_reached()) {
return NULL;
}
if (exit) {
if (!tag_stack.size()) {
if (!p_printerr)
return NULL;
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Unmatched exit tag </"+tag.name+">");
ERR_FAIL_COND_V(!tag_stack.size(),NULL);
}
if (tag_stack.back()->get().name!=tag.name) {
if (!p_printerr)
return NULL;
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Mismatched exit tag. Got </"+tag.name+">, expected </"+tag_stack.back()->get().name+">");
ERR_FAIL_COND_V(tag_stack.back()->get().name!=tag.name,NULL);
}
if (!complete) {
while(get_char()!='>' && !f->eof_reached()) {}
if (f->eof_reached())
return NULL;
}
if (r_exit)
*r_exit=true;
tag_stack.pop_back();
return NULL;
}
if (!complete) {
String name;
CharString r_value;
bool reading_value=false;
while(!f->eof_reached()) {
CharType c=get_char();
if (c=='>') {
if (r_value.size()) {
r_value.push_back(0);
String str;
str.parse_utf8(r_value.get_data());
tag.args[name]=str;
if (r_order)
r_order->push_back(name);
}
break;
} else if ( ((!reading_value && (c<33)) || c=='=' || c=='"' || c=='\'') && tag.name.length()) {
if (!reading_value && name.length()) {
reading_value=true;
} else if (reading_value && r_value.size()) {
r_value.push_back(0);
String str;
str.parse_utf8(r_value.get_data());
tag.args[name]=str;
if (r_order)
r_order->push_back(name);
name="";
r_value.clear();
reading_value=false;
}
} else if (reading_value) {
r_value.push_back(c);
} else {
name+=c;
}
}
if (f->eof_reached())
return NULL;
}
tag_stack.push_back(tag);
return &tag_stack.back()->get();
}
Error ResourceInteractiveLoaderXML::close_tag(const String& p_name) {
int level=0;
bool inside_tag=false;
while(true) {
if (f->eof_reached()) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": EOF found while attempting to find </"+p_name+">");
ERR_FAIL_COND_V( f->eof_reached(), ERR_FILE_CORRUPT );
}
uint8_t c = get_char();
if (c == '<') {
if (inside_tag) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Malformed XML. Already inside Tag.");
ERR_FAIL_COND_V(inside_tag,ERR_FILE_CORRUPT);
}
inside_tag=true;
c = get_char();
if (c == '/') {
--level;
} else {
++level;
};
} else if (c == '>') {
if (!inside_tag) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Malformed XML. Already outside Tag");
ERR_FAIL_COND_V(!inside_tag,ERR_FILE_CORRUPT);
}
inside_tag=false;
if (level == -1) {
tag_stack.pop_back();
return OK;
};
};
}
return OK;
}
void ResourceInteractiveLoaderXML::unquote(String& p_str) {
p_str=p_str.strip_edges().replace("\"","").xml_unescape();
/*p_str=p_str.strip_edges();
p_str=p_str.replace("\"","");
p_str=p_str.replace("&gt;","<");
p_str=p_str.replace("&lt;",">");
p_str=p_str.replace("&apos;","'");
p_str=p_str.replace("&quot;","\"");
for (int i=1;i<32;i++) {
char chr[2]={i,0};
p_str=p_str.replace("&#"+String::num(i)+";",chr);
}
p_str=p_str.replace("&amp;","&");
*/
//p_str.parse_utf8( p_str.ascii(true).get_data() );
}
Error ResourceInteractiveLoaderXML::goto_end_of_tag() {
uint8_t c;
while(true) {
c=get_char();
if (c=='>') //closetag
break;
if (f->eof_reached()) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": EOF found while attempting to find close tag.");
ERR_FAIL_COND_V( f->eof_reached(), ERR_FILE_CORRUPT );
}
}
tag_stack.pop_back();
return OK;
}
Error ResourceInteractiveLoaderXML::parse_property_data(String &r_data) {
r_data="";
CharString cs;
while(true) {
CharType c=get_char();
if (c=='<')
break;
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
cs.push_back(c);
}
cs.push_back(0);
r_data.parse_utf8(cs.get_data());
while(get_char()!='>' && !f->eof_reached()) {}
if (f->eof_reached()) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Malformed XML.");
ERR_FAIL_COND_V( f->eof_reached(), ERR_FILE_CORRUPT );
}
r_data=r_data.strip_edges();
tag_stack.pop_back();
return OK;
}
Error ResourceInteractiveLoaderXML::_parse_array_element(Vector<char> &buff,bool p_number_only,FileAccess *f,bool *end) {
if (buff.empty())
buff.resize(32); // optimi
int buff_max=buff.size();
int buff_size=0;
*end=false;
char *buffptr=&buff[0];
bool found=false;
bool quoted=false;
while(true) {
char c=get_char();
if (c==0) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": File corrupt (zero found).");
ERR_FAIL_V(ERR_FILE_CORRUPT);
} else if (c=='"') {
quoted=!quoted;
} else if ((!quoted && ((p_number_only && c<33) || c==',')) || c=='<') {
if (c=='<') {
*end=true;
break;
}
if (c<32 && f->eof_reached()) {
*end=true;
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": File corrupt (unexpected EOF).");
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
if (found)
break;
} else {
found=true;
if (buff_size>=buff_max) {
buff_max++;
buff.resize(buff_max);
buffptr=buff.ptr();
}
buffptr[buff_size]=c;
buff_size++;
}
}
if (buff_size>=buff_max) {
buff_max++;
buff.resize(buff_max);
}
buff[buff_size]=0;
buff_size++;
return OK;
}
Error ResourceInteractiveLoaderXML::parse_property(Variant& r_v, String &r_name) {
bool exit;
Tag *tag = parse_tag(&exit);
if (!tag) {
if (exit) // shouldn't have exited
return ERR_FILE_EOF;
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": File corrupt (No Property Tag).");
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
r_v=Variant();
r_name="";
//ERR_FAIL_COND_V(tag->name!="property",ERR_FILE_CORRUPT);
//ERR_FAIL_COND_V(!tag->args.has("name"),ERR_FILE_CORRUPT);
// ERR_FAIL_COND_V(!tag->args.has("type"),ERR_FILE_CORRUPT);
//String name=tag->args["name"];
//ERR_FAIL_COND_V(name=="",ERR_FILE_CORRUPT);
String type=tag->name;
String name=tag->args["name"];
if (type=="") {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": 'type' field is empty.");
ERR_FAIL_COND_V(type=="",ERR_FILE_CORRUPT);
}
if (type=="dictionary") {
Dictionary d( tag->args.has("shared") && (String(tag->args["shared"])=="true" || String(tag->args["shared"])=="1"));
while(true) {
Error err;
String tagname;
Variant key;
int dictline = get_current_line();
err=parse_property(key,tagname);
if (err && err!=ERR_FILE_EOF) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Error parsing dictionary: "+name+" (from line "+itos(dictline)+")");
ERR_FAIL_COND_V(err && err!=ERR_FILE_EOF,err);
}
//ERR_FAIL_COND_V(tagname!="key",ERR_FILE_CORRUPT);
if (err)
break;
Variant value;
err=parse_property(value,tagname);
if (err) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Error parsing dictionary: "+name+" (from line "+itos(dictline)+")");
}
ERR_FAIL_COND_V(err,err);
//ERR_FAIL_COND_V(tagname!="value",ERR_FILE_CORRUPT);
d[key]=value;
}
//err=parse_property_data(name); // skip the rest
//ERR_FAIL_COND_V(err,err);
r_name=name;
r_v=d;
return OK;
} else if (type=="array") {
if (!tag->args.has("len")) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Array missing 'len' field: "+name);
ERR_FAIL_COND_V(!tag->args.has("len"),ERR_FILE_CORRUPT);
}
int len=tag->args["len"].to_int();
bool shared = tag->args.has("shared") && (String(tag->args["shared"])=="true" || String(tag->args["shared"])=="1");
Array array(shared);
array.resize(len);
Error err;
Variant v;
String tagname;
int idx=0;
while( (err=parse_property(v,tagname))==OK ) {
ERR_CONTINUE( idx <0 || idx >=len );
array.set(idx,v);
idx++;
}
if (idx!=len) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Error loading array (size mismatch): "+name);
ERR_FAIL_COND_V(idx!=len,err);
}
if (err!=ERR_FILE_EOF) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Error loading array: "+name);
ERR_FAIL_COND_V(err!=ERR_FILE_EOF,err);
}
//err=parse_property_data(name); // skip the rest
//ERR_FAIL_COND_V(err,err);
r_name=name;
r_v=array;
return OK;
} else if (type=="resource") {
if (tag->args.has("path")) {
String path=tag->args["path"];
String hint;
if (tag->args.has("resource_type"))
hint=tag->args["resource_type"];
if (path.begins_with("local://"))
path=path.replace("local://",local_path+"::");
else 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().plus_file(path));
}
if (remaps.has(path)) {
path=remaps[path];
}
//take advantage of the resource loader cache. The resource is cached on it, even if
RES res=ResourceLoader::load(path,hint);
if (res.is_null()) {
WARN_PRINT(String("Couldn't load resource: "+path).ascii().get_data());
}
r_v=res.get_ref_ptr();
} else if (tag->args.has("external")) {
int index = tag->args["external"].to_int();
if (ext_resources.has(index)) {
String path=ext_resources[index].path;
String type=ext_resources[index].type;
//take advantage of the resource loader cache. The resource is cached on it, even if
RES res=ResourceLoader::load(path,type);
if (res.is_null()) {
WARN_PRINT(String("Couldn't load externalresource: "+path).ascii().get_data());
}
r_v=res.get_ref_ptr();
} else {
WARN_PRINT(String("Invalid external resource index: "+itos(index)).ascii().get_data());
}
}
Error err=goto_end_of_tag();
if (err) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Error closing <resource> tag.");
ERR_FAIL_COND_V(err,err);
}
r_name=name;
return OK;
} else if (type=="image") {
if (!tag->args.has("encoding")) {
//empty image
r_v=Image();
String sdfsdfg;
Error err=parse_property_data(sdfsdfg);
return OK;
}
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Image missing 'encoding' field.");
ERR_FAIL_COND_V( !tag->args.has("encoding"), ERR_FILE_CORRUPT );
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Image missing 'width' field.");
ERR_FAIL_COND_V( !tag->args.has("width"), ERR_FILE_CORRUPT );
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Image missing 'height' field.");
ERR_FAIL_COND_V( !tag->args.has("height"), ERR_FILE_CORRUPT );
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Image missing 'format' field.");
ERR_FAIL_COND_V( !tag->args.has("format"), ERR_FILE_CORRUPT );
String encoding=tag->args["encoding"];
if (encoding=="raw") {
String width=tag->args["width"];
String height=tag->args["height"];
String format=tag->args["format"];
int mipmaps=tag->args.has("mipmaps")?int(tag->args["mipmaps"].to_int()):int(0);
int custom_size = tag->args.has("custom_size")?int(tag->args["custom_size"].to_int()):int(0);
r_name=name;
Image::Format imgformat;
if (format=="grayscale") {
imgformat=Image::FORMAT_GRAYSCALE;
} else if (format=="intensity") {
imgformat=Image::FORMAT_INTENSITY;
} else if (format=="grayscale_alpha") {
imgformat=Image::FORMAT_GRAYSCALE_ALPHA;
} else if (format=="rgb") {
imgformat=Image::FORMAT_RGB;
} else if (format=="rgba") {
imgformat=Image::FORMAT_RGBA;
} else if (format=="indexed") {
imgformat=Image::FORMAT_INDEXED;
} else if (format=="indexed_alpha") {
imgformat=Image::FORMAT_INDEXED_ALPHA;
} else if (format=="bc1") {
imgformat=Image::FORMAT_BC1;
} else if (format=="bc2") {
imgformat=Image::FORMAT_BC2;
} else if (format=="bc3") {
imgformat=Image::FORMAT_BC3;
} else if (format=="bc4") {
imgformat=Image::FORMAT_BC4;
} else if (format=="bc5") {
imgformat=Image::FORMAT_BC5;
} else if (format=="pvrtc2") {
imgformat=Image::FORMAT_PVRTC2;
} else if (format=="pvrtc2a") {
imgformat=Image::FORMAT_PVRTC2_ALPHA;
} else if (format=="pvrtc4") {
imgformat=Image::FORMAT_PVRTC4;
} else if (format=="pvrtc4a") {
imgformat=Image::FORMAT_PVRTC4_ALPHA;
} else if (format=="etc") {
imgformat=Image::FORMAT_ETC;
} else if (format=="atc") {
imgformat=Image::FORMAT_ATC;
} else if (format=="atcai") {
imgformat=Image::FORMAT_ATC_ALPHA_INTERPOLATED;
} else if (format=="atcae") {
imgformat=Image::FORMAT_ATC_ALPHA_EXPLICIT;
} else if (format=="custom") {
imgformat=Image::FORMAT_CUSTOM;
} else {
ERR_FAIL_V( ERR_FILE_CORRUPT );
}
int datasize;
int w=width.to_int();
int h=height.to_int();
if (w == 0 && h == 0) {
//r_v = Image(w, h, imgformat);
r_v=Image();
String sdfsdfg;
Error err=parse_property_data(sdfsdfg);
return OK;
};
if (imgformat==Image::FORMAT_CUSTOM) {
datasize=custom_size;
} else {
datasize = Image::get_image_data_size(h,w,imgformat,mipmaps);
}
if (datasize==0) {
//r_v = Image(w, h, imgformat);
r_v=Image();
String sdfsdfg;
Error err=parse_property_data(sdfsdfg);
return OK;
};
DVector<uint8_t> pixels;
pixels.resize(datasize);
DVector<uint8_t>::Write wb = pixels.write();
int idx=0;
uint8_t byte;
while( idx<datasize*2) {
CharType c=get_char();
ERR_FAIL_COND_V(c=='<',ERR_FILE_CORRUPT);
if ( (c>='0' && c<='9') || (c>='A' && c<='F') || (c>='a' && c<='f') ) {
if (idx&1) {
byte|=HEX2CHR(c);
wb[idx>>1]=byte;
} else {
byte=HEX2CHR(c)<<4;
}
idx++;
}
}
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
wb=DVector<uint8_t>::Write();
r_v=Image(w,h,mipmaps,imgformat,pixels);
String sdfsdfg;
Error err=parse_property_data(sdfsdfg);
ERR_FAIL_COND_V(err,err);
return OK;
}
ERR_FAIL_V(ERR_FILE_CORRUPT);
} else if (type=="raw_array") {
if (!tag->args.has("len")) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": RawArray missing 'len' field: "+name);
ERR_FAIL_COND_V(!tag->args.has("len"),ERR_FILE_CORRUPT);
}
int len=tag->args["len"].to_int();
DVector<uint8_t> bytes;
bytes.resize(len);
DVector<uint8_t>::Write w=bytes.write();
uint8_t *bytesptr=w.ptr();
int idx=0;
uint8_t byte;
while( idx<len*2) {
CharType c=get_char();
if (c<=32)
continue;
if (idx&1) {
byte|=HEX2CHR(c);
bytesptr[idx>>1]=byte;
//printf("%x\n",int(byte));
} else {
byte=HEX2CHR(c)<<4;
}
idx++;
}
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
w=DVector<uint8_t>::Write();
r_v=bytes;
String sdfsdfg;
Error err=parse_property_data(sdfsdfg);
ERR_FAIL_COND_V(err,err);
r_name=name;
return OK;
} else if (type=="int_array") {
if (!tag->args.has("len")) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Array missing 'len' field: "+name);
ERR_FAIL_COND_V(!tag->args.has("len"),ERR_FILE_CORRUPT);
}
int len=tag->args["len"].to_int();
DVector<int> ints;
ints.resize(len);
DVector<int>::Write w=ints.write();
int *intsptr=w.ptr();
int idx=0;
String str;
#if 0
while( idx<len ) {
CharType c=get_char();
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
if (c<33 || c==',' || c=='<') {
if (str.length()) {
intsptr[idx]=str.to_int();
str="";
idx++;
}
if (c=='<') {
while(get_char()!='>' && !f->eof_reached()) {}
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
break;
}
} else {
str+=c;
}
}
#else
Vector<char> tmpdata;
while( idx<len ) {
bool end=false;
Error err = _parse_array_element(tmpdata,true,f,&end);
ERR_FAIL_COND_V(err,err);
intsptr[idx]=String::to_int(&tmpdata[0]);
idx++;
if (end)
break;
}
#endif
w=DVector<int>::Write();
r_v=ints;
Error err=goto_end_of_tag();
ERR_FAIL_COND_V(err,err);
r_name=name;
return OK;
} else if (type=="real_array") {
if (!tag->args.has("len")) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Array missing 'len' field: "+name);
ERR_FAIL_COND_V(!tag->args.has("len"),ERR_FILE_CORRUPT);
}
int len=tag->args["len"].to_int();;
DVector<real_t> reals;
reals.resize(len);
DVector<real_t>::Write w=reals.write();
real_t *realsptr=w.ptr();
int idx=0;
String str;
#if 0
while( idx<len ) {
CharType c=get_char();
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
if (c<33 || c==',' || c=='<') {
if (str.length()) {
realsptr[idx]=str.to_double();
str="";
idx++;
}
if (c=='<') {
while(get_char()!='>' && !f->eof_reached()) {}
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
break;
}
} else {
str+=c;
}
}
#else
Vector<char> tmpdata;
while( idx<len ) {
bool end=false;
Error err = _parse_array_element(tmpdata,true,f,&end);
ERR_FAIL_COND_V(err,err);
realsptr[idx]=String::to_double(&tmpdata[0]);
idx++;
if (end)
break;
}
#endif
w=DVector<real_t>::Write();
r_v=reals;
Error err=goto_end_of_tag();
ERR_FAIL_COND_V(err,err);
r_name=name;
return OK;
} else if (type=="string_array") {
#if 0
if (!tag->args.has("len")) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Array missing 'len' field: "+name);
ERR_FAIL_COND_V(!tag->args.has("len"),ERR_FILE_CORRUPT);
}
int len=tag->args["len"].to_int();
DVector<String> strings;
strings.resize(len);
DVector<String>::Write w=strings.write();
String *stringsptr=w.ptr();
int idx=0;
String str;
bool inside_str=false;
CharString cs;
while( idx<len ) {
CharType c=get_char();
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
if (c=='"') {
if (inside_str) {
cs.push_back(0);
String str;
str.parse_utf8(cs.get_data());
unquote(str);
stringsptr[idx]=str;
cs.clear();
idx++;
inside_str=false;
} else {
inside_str=true;
}
} else if (c=='<') {
while(get_char()!='>' && !f->eof_reached()) {}
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
break;
} else if (inside_str){
cs.push_back(c);
}
}
w=DVector<String>::Write();
r_v=strings;
String sdfsdfg;
Error err=parse_property_data(sdfsdfg);
ERR_FAIL_COND_V(err,err);
r_name=name;
return OK;
#endif
if (!tag->args.has("len")) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": String Array missing 'len' field: "+name);
ERR_FAIL_COND_V(!tag->args.has("len"),ERR_FILE_CORRUPT);
}
int len=tag->args["len"].to_int();
StringArray array;
array.resize(len);
DVector<String>::Write w = array.write();
Error err;
Variant v;
String tagname;
int idx=0;
while( (err=parse_property(v,tagname))==OK ) {
ERR_CONTINUE( idx <0 || idx >=len );
String str = v; //convert back to string
w[idx]=str;
idx++;
}
if (idx!=len) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Error loading array (size mismatch): "+name);
ERR_FAIL_COND_V(idx!=len,err);
}
if (err!=ERR_FILE_EOF) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Error loading array: "+name);
ERR_FAIL_COND_V(err!=ERR_FILE_EOF,err);
}
//err=parse_property_data(name); // skip the rest
//ERR_FAIL_COND_V(err,err);
r_name=name;
r_v=array;
return OK;
} else if (type=="vector3_array") {
if (!tag->args.has("len")) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Array missing 'len' field: "+name);
ERR_FAIL_COND_V(!tag->args.has("len"),ERR_FILE_CORRUPT);
}
int len=tag->args["len"].to_int();;
DVector<Vector3> vectors;
vectors.resize(len);
DVector<Vector3>::Write w=vectors.write();
Vector3 *vectorsptr=w.ptr();
int idx=0;
int subidx=0;
Vector3 auxvec;
String str;
// uint64_t tbegin = OS::get_singleton()->get_ticks_usec();
#if 0
while( idx<len ) {
CharType c=get_char();
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
if (c<33 || c==',' || c=='<') {
if (str.length()) {
auxvec[subidx]=str.to_double();
subidx++;
str="";
if (subidx==3) {
vectorsptr[idx]=auxvec;
idx++;
subidx=0;
}
}
if (c=='<') {
while(get_char()!='>' && !f->eof_reached()) {}
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
break;
}
} else {
str+=c;
}
}
#else
Vector<char> tmpdata;
while( idx<len ) {
bool end=false;
Error err = _parse_array_element(tmpdata,true,f,&end);
ERR_FAIL_COND_V(err,err);
auxvec[subidx]=String::to_double(&tmpdata[0]);
subidx++;
if (subidx==3) {
vectorsptr[idx]=auxvec;
idx++;
subidx=0;
}
if (end)
break;
}
#endif
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Premature end of vector3 array");
ERR_FAIL_COND_V(idx<len,ERR_FILE_CORRUPT);
// double time_taken = (OS::get_singleton()->get_ticks_usec() - tbegin)/1000000.0;
w=DVector<Vector3>::Write();
r_v=vectors;
String sdfsdfg;
Error err=goto_end_of_tag();
ERR_FAIL_COND_V(err,err);
r_name=name;
return OK;
} else if (type=="vector2_array") {
if (!tag->args.has("len")) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Array missing 'len' field: "+name);
ERR_FAIL_COND_V(!tag->args.has("len"),ERR_FILE_CORRUPT);
}
int len=tag->args["len"].to_int();;
DVector<Vector2> vectors;
vectors.resize(len);
DVector<Vector2>::Write w=vectors.write();
Vector2 *vectorsptr=w.ptr();
int idx=0;
int subidx=0;
Vector2 auxvec;
String str;
// uint64_t tbegin = OS::get_singleton()->get_ticks_usec();
#if 0
while( idx<len ) {
CharType c=get_char();
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
if (c<22 || c==',' || c=='<') {
if (str.length()) {
auxvec[subidx]=str.to_double();
subidx++;
str="";
if (subidx==2) {
vectorsptr[idx]=auxvec;
idx++;
subidx=0;
}
}
if (c=='<') {
while(get_char()!='>' && !f->eof_reached()) {}
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
break;
}
} else {
str+=c;
}
}
#else
Vector<char> tmpdata;
while( idx<len ) {
bool end=false;
Error err = _parse_array_element(tmpdata,true,f,&end);
ERR_FAIL_COND_V(err,err);
auxvec[subidx]=String::to_double(&tmpdata[0]);
subidx++;
if (subidx==2) {
vectorsptr[idx]=auxvec;
idx++;
subidx=0;
}
if (end)
break;
}
#endif
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Premature end of vector2 array");
ERR_FAIL_COND_V(idx<len,ERR_FILE_CORRUPT);
// double time_taken = (OS::get_singleton()->get_ticks_usec() - tbegin)/1000000.0;
w=DVector<Vector2>::Write();
r_v=vectors;
String sdfsdfg;
Error err=goto_end_of_tag();
ERR_FAIL_COND_V(err,err);
r_name=name;
return OK;
} else if (type=="color_array") {
if (!tag->args.has("len")) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Array missing 'len' field: "+name);
ERR_FAIL_COND_V(!tag->args.has("len"),ERR_FILE_CORRUPT);
}
int len=tag->args["len"].to_int();;
DVector<Color> colors;
colors.resize(len);
DVector<Color>::Write w=colors.write();
Color *colorsptr=w.ptr();
int idx=0;
int subidx=0;
Color auxcol;
String str;
while( idx<len ) {
CharType c=get_char();
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
if (c<33 || c==',' || c=='<') {
if (str.length()) {
auxcol[subidx]=str.to_double();
subidx++;
str="";
if (subidx==4) {
colorsptr[idx]=auxcol;
idx++;
subidx=0;
}
}
if (c=='<') {
while(get_char()!='>' && !f->eof_reached()) {}
ERR_FAIL_COND_V(f->eof_reached(),ERR_FILE_CORRUPT);
break;
}
} else {
str+=c;
}
}
w=DVector<Color>::Write();
r_v=colors;
String sdfsdfg;
Error err=parse_property_data(sdfsdfg);
ERR_FAIL_COND_V(err,err);
r_name=name;
return OK;
}
String data;
Error err = parse_property_data(data);
ERR_FAIL_COND_V(err!=OK,err);
if (type=="nil") {
// uh do nothing
} else if (type=="bool") {
// uh do nothing
if (data.nocasecmp_to("true")==0 || data.to_int()!=0)
r_v=true;
else
r_v=false;
} else if (type=="int") {
r_v=data.to_int();
} else if (type=="real") {
r_v=data.to_double();
} else if (type=="string") {
String str=data;
unquote(str);
r_v=str;
} else if (type=="vector3") {
r_v=Vector3(
data.get_slicec(',',0).to_double(),
data.get_slicec(',',1).to_double(),
data.get_slicec(',',2).to_double()
);
} else if (type=="vector2") {
r_v=Vector2(
data.get_slicec(',',0).to_double(),
data.get_slicec(',',1).to_double()
);
} else if (type=="plane") {
r_v=Plane(
data.get_slicec(',',0).to_double(),
data.get_slicec(',',1).to_double(),
data.get_slicec(',',2).to_double(),
data.get_slicec(',',3).to_double()
);
} else if (type=="quaternion") {
r_v=Quat(
data.get_slicec(',',0).to_double(),
data.get_slicec(',',1).to_double(),
data.get_slicec(',',2).to_double(),
data.get_slicec(',',3).to_double()
);
} else if (type=="rect2") {
r_v=Rect2(
Vector2(
data.get_slicec(',',0).to_double(),
data.get_slicec(',',1).to_double()
),
Vector2(
data.get_slicec(',',2).to_double(),
data.get_slicec(',',3).to_double()
)
);
} else if (type=="aabb") {
r_v=AABB(
Vector3(
data.get_slicec(',',0).to_double(),
data.get_slicec(',',1).to_double(),
data.get_slicec(',',2).to_double()
),
Vector3(
data.get_slicec(',',3).to_double(),
data.get_slicec(',',4).to_double(),
data.get_slicec(',',5).to_double()
)
);
} else if (type=="matrix32") {
Matrix32 m3;
for (int i=0;i<3;i++) {
for (int j=0;j<2;j++) {
m3.elements[i][j]=data.get_slicec(',',i*2+j).to_double();
}
}
r_v=m3;
} else if (type=="matrix3") {
Matrix3 m3;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++) {
m3.elements[i][j]=data.get_slicec(',',i*3+j).to_double();
}
}
r_v=m3;
} else if (type=="transform") {
Transform tr;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++) {
tr.basis.elements[i][j]=data.get_slicec(',',i*3+j).to_double();
}
}
tr.origin=Vector3(
data.get_slicec(',',9).to_double(),
data.get_slicec(',',10).to_double(),
data.get_slicec(',',11).to_double()
);
r_v=tr;
} else if (type=="color") {
r_v=Color(
data.get_slicec(',',0).to_double(),
data.get_slicec(',',1).to_double(),
data.get_slicec(',',2).to_double(),
data.get_slicec(',',3).to_double()
);
} else if (type=="node_path") {
String str=data;
unquote(str);
r_v=NodePath( str );
} else if (type=="input_event") {
// ?
} else {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Unrecognized tag in file: "+type);
ERR_FAIL_V(ERR_FILE_CORRUPT);
}
r_name=name;
return OK;
}
int ResourceInteractiveLoaderXML::get_current_line() const {
return lines;
}
uint8_t ResourceInteractiveLoaderXML::get_char() const {
uint8_t c = f->get_8();
if (c=='\n')
lines++;
return c;
}
///
void ResourceInteractiveLoaderXML::set_local_path(const String& p_local_path) {
res_path=p_local_path;
}
Ref<Resource> ResourceInteractiveLoaderXML::get_resource() {
return resource;
}
Error ResourceInteractiveLoaderXML::poll() {
if (error!=OK)
return error;
bool exit;
Tag *tag = parse_tag(&exit);
if (!tag) {
error=ERR_FILE_CORRUPT;
if (!exit) // shouldn't have exited
ERR_FAIL_V(error);
error=ERR_FILE_EOF;
return error;
}
RES res;
//Object *obj=NULL;
bool main;
if (tag->name=="ext_resource") {
error=ERR_FILE_CORRUPT;
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": <ext_resource> missing 'path' field.");
ERR_FAIL_COND_V(!tag->args.has("path"),ERR_FILE_CORRUPT);
String type="Resource";
if (tag->args.has("type"))
type=tag->args["type"];
String path = tag->args["path"];
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": <ext_resource> can't use a local path, this is a bug?.");
ERR_FAIL_COND_V(path.begins_with("local://"),ERR_FILE_CORRUPT);
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().plus_file(path));
}
if (remaps.has(path)) {
path=remaps[path];
}
RES res = ResourceLoader::load(path,type);
if (res.is_null()) {
if (ResourceLoader::get_abort_on_missing_resources()) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": <ext_resource> referenced nonexistent resource at: "+path);
ERR_FAIL_V(error);
} else {
ResourceLoader::notify_dependency_error(local_path,path,type);
}
} else {
resource_cache.push_back(res);
}
if (tag->args.has("index")) {
ExtResource er;
er.path=path;
er.type=type;
ext_resources[tag->args["index"].to_int()]=er;
}
Error err = close_tag("ext_resource");
if (err)
return error;
error=OK;
resource_current++;
return error;
} else if (tag->name=="resource") {
main=false;
} else if (tag->name=="main_resource") {
main=true;
} else {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": unexpected main tag: "+tag->name);
error=ERR_FILE_CORRUPT;
ERR_FAIL_V(error);
}
String type;
String path;
int subres=0;
if (!main) {
//loading resource
error=ERR_FILE_CORRUPT;
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": <resource> missing 'len' field.");
ERR_FAIL_COND_V(!tag->args.has("path"),ERR_FILE_CORRUPT);
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": <resource> missing 'type' field.");
ERR_FAIL_COND_V(!tag->args.has("type"),ERR_FILE_CORRUPT);
path=tag->args["path"];
error=OK;
if (path.begins_with("local://")) {
//built-in resource (but really external)
path=path.replace("local://","");
subres=path.to_int();
path=local_path+"::"+path;
}
if (ResourceCache::has(path)) {
Error err = close_tag(tag->name);
if (err) {
error=ERR_FILE_CORRUPT;
}
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Unable to close <resource> tag.");
ERR_FAIL_COND_V( err, err );
resource_current++;
error=OK;
return OK;
}
type = tag->args["type"];
} else {
type=resource_type;
}
Object *obj = ObjectTypeDB::instance(type);
if (!obj) {
error=ERR_FILE_CORRUPT;
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": Object of unrecognized type in file: "+type);
}
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+":"+itos(get_current_line())+": Object type in resource field not a resource, type is: "+obj->get_type());
ERR_FAIL_COND_V(!r,ERR_FILE_CORRUPT);
}
res = RES( r );
if (path!="")
r->set_path(path);
r->set_subindex(subres);
//load properties
while(true) {
String name;
Variant v;
Error err;
err = parse_property(v,name);
if (err==ERR_FILE_EOF) //tag closed
break;
if (err!=OK) {
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": XML Parsing aborted.");
ERR_FAIL_COND_V(err!=OK,ERR_FILE_CORRUPT);
}
obj->set(name,v);
}
#ifdef TOOLS_ENABLED
res->set_edited(false);
#endif
resource_cache.push_back(res); //keep it in mem until finished loading
resource_current++;
if (main) {
f->close();
resource=res;
resource->set_path(res_path);
error=ERR_FILE_EOF;
return error;
}
error=OK;
return OK;
}
int ResourceInteractiveLoaderXML::get_stage() const {
return resource_current;
}
int ResourceInteractiveLoaderXML::get_stage_count() const {
return resources_total;//+ext_resources;
}
ResourceInteractiveLoaderXML::~ResourceInteractiveLoaderXML() {
memdelete(f);
}
void ResourceInteractiveLoaderXML::get_dependencies(FileAccess *f,List<String> *p_dependencies,bool p_add_types) {
open(f);
ERR_FAIL_COND(error!=OK);
while(true) {
bool exit;
Tag *tag = parse_tag(&exit);
if (!tag) {
error=ERR_FILE_CORRUPT;
ERR_FAIL_COND(!exit);
error=ERR_FILE_EOF;
return;
}
if (tag->name!="ext_resource") {
return;
}
error=ERR_FILE_CORRUPT;
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": <ext_resource> missing 'path' field.");
ERR_FAIL_COND(!tag->args.has("path"));
String path = tag->args["path"];
ERR_EXPLAIN(local_path+":"+itos(get_current_line())+": <ext_resource> can't use a local path, this is a bug?.");
ERR_FAIL_COND(path.begins_with("local://"));
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().plus_file(path));
}
if (path.ends_with("*")) {
ERR_FAIL_COND(!tag->args.has("type"));
String type = tag->args["type"];
path = ResourceLoader::guess_full_filename(path,type);
}
if (p_add_types && tag->args.has("type")) {
path+="::"+tag->args["type"];
}
p_dependencies->push_back(path);
Error err = close_tag("ext_resource");
if (err)
return;
error=OK;
}
}
Error ResourceInteractiveLoaderXML::rename_dependencies(FileAccess *p_f, const String &p_path,const Map<String,String>& p_map) {
open(p_f);
ERR_FAIL_COND_V(error!=OK,error);
//FileAccess
bool old_format=false;
FileAccess *fw = NULL;
String base_path=local_path.get_base_dir();
while(true) {
bool exit;
List<String> order;
Tag *tag = parse_tag(&exit,true,&order);
bool done=false;
if (!tag) {
if (fw) {
memdelete(fw);
}
error=ERR_FILE_CORRUPT;
ERR_FAIL_COND_V(!exit,error);
error=ERR_FILE_EOF;
return error;
}
if (tag->name=="ext_resource") {
if (!tag->args.has("index") || !tag->args.has("path") || !tag->args.has("type")) {
old_format=true;
break;
}
if (!fw) {
fw=FileAccess::open(p_path+".depren",FileAccess::WRITE);
fw->store_line("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"); //no escape
fw->store_line("<resource_file type=\""+resource_type+"\" subresource_count=\""+itos(resources_total)+"\" version=\""+itos(VERSION_MAJOR)+"."+itos(VERSION_MINOR)+"\" version_name=\""+VERSION_FULL_NAME+"\">");
}
String path = tag->args["path"];
String index = tag->args["index"];
String type = tag->args["type"];
bool relative=false;
if (!path.begins_with("res://")) {
path=base_path.plus_file(path).simplify_path();
relative=true;
}
if (p_map.has(path)) {
String np=p_map[path];
path=np;
}
if (relative) {
//restore relative
path=base_path.path_to_file(path);
}
tag->args["path"]=path;
tag->args["index"]=index;
tag->args["type"]=type;
} else {
done=true;
}
String tagt="\t<";
if (exit)
tagt+="/";
tagt+=tag->name;
for(List<String>::Element *E=order.front();E;E=E->next()) {
tagt+=" "+E->get()+"=\""+tag->args[E->get()]+"\"";
}
tagt+=">";
fw->store_line(tagt);
if (done)
break;
close_tag("ext_resource");
fw->store_line("\t</ext_resource>");
}
if (old_format) {
if (fw)
memdelete(fw);
DirAccess *da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
da->remove(p_path+".depren");
memdelete(da);
//fuck it, use the old approach;
WARN_PRINT(("This file is old, so it can't refactor dependencies, opening and resaving: "+p_path).utf8().get_data());
Error err;
FileAccess *f2 = FileAccess::open(p_path,FileAccess::READ,&err);
if (err!=OK) {
ERR_FAIL_COND_V(err!=OK,ERR_FILE_CANT_OPEN);
}
Ref<ResourceInteractiveLoaderXML> ria = memnew( ResourceInteractiveLoaderXML );
ria->local_path=Globals::get_singleton()->localize_path(p_path);
ria->res_path=ria->local_path;
ria->remaps=p_map;
// ria->set_local_path( Globals::get_singleton()->localize_path(p_path) );
ria->open(f2);
err = ria->poll();
while(err==OK) {
err=ria->poll();
}
ERR_FAIL_COND_V(err!=ERR_FILE_EOF,ERR_FILE_CORRUPT);
RES res = ria->get_resource();
ERR_FAIL_COND_V(!res.is_valid(),ERR_FILE_CORRUPT);
return ResourceFormatSaverXML::singleton->save(p_path,res);
}
if (!fw) {
return OK; //nothing to rename, do nothing
}
uint8_t c=f->get_8();
while(!f->eof_reached()) {
fw->store_8(c);
c=f->get_8();
}
bool all_ok = fw->get_error()==OK;
memdelete(fw);
if (!all_ok) {
return ERR_CANT_CREATE;
}
DirAccess *da = DirAccess::create(DirAccess::ACCESS_RESOURCES);
da->remove(p_path);
da->rename(p_path+".depren",p_path);
memdelete(da);
return OK;
}
void ResourceInteractiveLoaderXML::open(FileAccess *p_f) {
error=OK;
lines=1;
f=p_f;
ResourceInteractiveLoaderXML::Tag *tag = parse_tag();
if (!tag || tag->name!="?xml" || !tag->args.has("version") || !tag->args.has("encoding") || tag->args["encoding"]!="UTF-8") {
error=ERR_FILE_CORRUPT;
ResourceLoader::notify_load_error("XML is invalid (missing header tags)");
ERR_EXPLAIN("Not a XML:UTF-8 File: "+local_path);
ERR_FAIL();
}
tag_stack.clear();
tag = parse_tag();
if (!tag || tag->name!="resource_file" || !tag->args.has("type") || !tag->args.has("version")) {
ResourceLoader::notify_load_error(local_path+": XML is not a valid resource file.");
error=ERR_FILE_CORRUPT;
ERR_EXPLAIN("Unrecognized XML File: "+local_path);
ERR_FAIL();
}
if (tag->args.has("subresource_count"))
resources_total=tag->args["subresource_count"].to_int();
resource_current=0;
resource_type=tag->args["type"];
String version = tag->args["version"];
if (version.get_slice_count(".")!=2) {
error=ERR_FILE_CORRUPT;
ResourceLoader::notify_load_error(local_path+":XML version string is invalid: "+version);
ERR_EXPLAIN("Invalid Version String '"+version+"'' in file: "+local_path);
ERR_FAIL();
}
int major = version.get_slicec('.',0).to_int();
int minor = version.get_slicec('.',1).to_int();
if (major>VERSION_MAJOR) {
error=ERR_FILE_UNRECOGNIZED;
ResourceLoader::notify_load_error(local_path+": File Format '"+version+"' is too new. Please upgrade to a newer engine version.");
ERR_EXPLAIN("File Format '"+version+"' is too new! Please upgrade to a a new engine version: "+local_path);
ERR_FAIL();
}
/*
String preload_depts = "deps/"+local_path.md5_text();
if (Globals::get_singleton()->has(preload_depts)) {
ext_resources.clear();
//ignore external resources and use these
NodePath depts=Globals::get_singleton()->get(preload_depts);
for(int i=0;i<depts.get_name_count();i++) {
ext_resources.push_back(depts.get_name(i));
}
print_line(local_path+" - EXTERNAL RESOURCES: "+itos(ext_resources.size()));
}
*/
}
String ResourceInteractiveLoaderXML::recognize(FileAccess *p_f) {
error=OK;
lines=1;
f=p_f;
ResourceInteractiveLoaderXML::Tag *tag = parse_tag();
if (!tag || tag->name!="?xml" || !tag->args.has("version") || !tag->args.has("encoding") || tag->args["encoding"]!="UTF-8") {
return ""; //unrecognized
}
tag_stack.clear();
tag = parse_tag();
if (!tag || tag->name!="resource_file" || !tag->args.has("type") || !tag->args.has("version")) {
return ""; //unrecognized
}
return tag->args["type"];
}
/////////////////////
Ref<ResourceInteractiveLoader> ResourceFormatLoaderXML::load_interactive(const String &p_path, Error *r_error) {
if (r_error)
*r_error=ERR_CANT_OPEN;
Error err;
FileAccess *f = FileAccess::open(p_path,FileAccess::READ,&err);
if (err!=OK) {
ERR_FAIL_COND_V(err!=OK,Ref<ResourceInteractiveLoader>());
}
Ref<ResourceInteractiveLoaderXML> ria = memnew( ResourceInteractiveLoaderXML );
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 ResourceFormatLoaderXML::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("xml");
}
void ResourceFormatLoaderXML::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("x"+ext);
}
p_extensions->push_back("xml");
}
bool ResourceFormatLoaderXML::handles_type(const String& p_type) const{
return true;
}
String ResourceFormatLoaderXML::get_resource_type(const String &p_path) const{
String ext=p_path.extension().to_lower();
if (!ext.begins_with("x")) //a lie but..
return "";
FileAccess *f = FileAccess::open(p_path,FileAccess::READ);
if (!f) {
return ""; //could not rwead
}
Ref<ResourceInteractiveLoaderXML> ria = memnew( ResourceInteractiveLoaderXML );
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 ResourceFormatLoaderXML::get_dependencies(const String& p_path,List<String> *p_dependencies,bool p_add_types) {
FileAccess *f = FileAccess::open(p_path,FileAccess::READ);
if (!f) {
ERR_FAIL();
}
Ref<ResourceInteractiveLoaderXML> ria = memnew( ResourceInteractiveLoaderXML );
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,p_add_types);
}
Error ResourceFormatLoaderXML::rename_dependencies(const String &p_path,const Map<String,String>& p_map) {
FileAccess *f = FileAccess::open(p_path,FileAccess::READ);
if (!f) {
ERR_FAIL_V(ERR_CANT_OPEN);
}
Ref<ResourceInteractiveLoaderXML> ria = memnew( ResourceInteractiveLoaderXML );
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) );
return ria->rename_dependencies(f,p_path,p_map);
}
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/
void ResourceFormatSaverXMLInstance::escape(String& p_str) {
p_str=p_str.replace("&","&amp;");
p_str=p_str.replace("<","&gt;");
p_str=p_str.replace(">","&lt;");
p_str=p_str.replace("'","&apos;");
p_str=p_str.replace("\"","&quot;");
for (char i=1;i<32;i++) {
char chr[2]={i,0};
const char hexn[16]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
const char hex[8]={'&','#','0','0',hexn[i>>4],hexn[i&0xf],';',0};
p_str=p_str.replace(chr,hex);
}
}
void ResourceFormatSaverXMLInstance::write_tabs(int p_diff) {
for (int i=0;i<depth+p_diff;i++) {
f->store_8('\t');
}
}
void ResourceFormatSaverXMLInstance::write_string(String p_str,bool p_escape) {
/* write an UTF8 string */
if (p_escape)
escape(p_str);
f->store_string(p_str);;
/*
CharString cs=p_str.utf8();
const char *data=cs.get_data();
while (*data) {
f->store_8(*data);
data++;
}*/
}
void ResourceFormatSaverXMLInstance::enter_tag(const char* p_tag,const String& p_args) {
f->store_8('<');
int cc = 0;
const char *c=p_tag;
while(*c) {
cc++;
c++;
}
f->store_buffer((const uint8_t*)p_tag,cc);
if (p_args.length()) {
f->store_8(' ');
f->store_string(p_args);
}
f->store_8('>');
depth++;
}
void ResourceFormatSaverXMLInstance::exit_tag(const char* p_tag) {
depth--;
f->store_8('<');
f->store_8('/');
int cc = 0;
const char *c=p_tag;
while(*c) {
cc++;
c++;
}
f->store_buffer((const uint8_t*)p_tag,cc);
f->store_8('>');
}
/*
static bool _check_type(const Variant& p_property) {
if (p_property.get_type()==Variant::_RID)
return false;
if (p_property.get_type()==Variant::OBJECT) {
RES res = p_property;
if (res.is_null())
return false;
}
return true;
}*/
void ResourceFormatSaverXMLInstance::write_property(const String& p_name,const Variant& p_property,bool *r_ok) {
if (r_ok)
*r_ok=false;
const char* type;
String params;
bool oneliner=true;
switch( p_property.get_type() ) {
case Variant::NIL: type="nil"; break;
case Variant::BOOL: type="bool"; break;
case Variant::INT: type="int"; break;
case Variant::REAL: type="real"; break;
case Variant::STRING: type="string"; break;
case Variant::VECTOR2: type="vector2"; break;
case Variant::RECT2: type="rect2"; break;
case Variant::VECTOR3: type="vector3"; break;
case Variant::PLANE: type="plane"; break;
case Variant::_AABB: type="aabb"; break;
case Variant::QUAT: type="quaternion"; break;
case Variant::MATRIX32: type="matrix32"; break;
case Variant::MATRIX3: type="matrix3"; break;
case Variant::TRANSFORM: type="transform"; break;
case Variant::COLOR: type="color"; break;
case Variant::IMAGE: {
type="image";
Image img=p_property;
if (img.empty()) {
write_tabs();
enter_tag(type,"name=\""+p_name+"\"");
exit_tag(type);
if (r_ok)
*r_ok=true;
return;
}
params+="encoding=\"raw\"";
params+=" width=\""+itos(img.get_width())+"\"";
params+=" height=\""+itos(img.get_height())+"\"";
params+=" mipmaps=\""+itos(img.get_mipmaps())+"\"";
switch(img.get_format()) {
case Image::FORMAT_GRAYSCALE: params+=" format=\"grayscale\""; break;
case Image::FORMAT_INTENSITY: params+=" format=\"intensity\""; break;
case Image::FORMAT_GRAYSCALE_ALPHA: params+=" format=\"grayscale_alpha\""; break;
case Image::FORMAT_RGB: params+=" format=\"rgb\""; break;
case Image::FORMAT_RGBA: params+=" format=\"rgba\""; break;
case Image::FORMAT_INDEXED : params+=" format=\"indexed\""; break;
case Image::FORMAT_INDEXED_ALPHA: params+=" format=\"indexed_alpha\""; break;
case Image::FORMAT_BC1: params+=" format=\"bc1\""; break;
case Image::FORMAT_BC2: params+=" format=\"bc2\""; break;
case Image::FORMAT_BC3: params+=" format=\"bc3\""; break;
case Image::FORMAT_BC4: params+=" format=\"bc4\""; break;
case Image::FORMAT_BC5: params+=" format=\"bc5\""; break;
case Image::FORMAT_PVRTC2: params+=" format=\"pvrtc2\""; break;
case Image::FORMAT_PVRTC2_ALPHA: params+=" format=\"pvrtc2a\""; break;
case Image::FORMAT_PVRTC4: params+=" format=\"pvrtc4\""; break;
case Image::FORMAT_PVRTC4_ALPHA: params+=" format=\"pvrtc4a\""; break;
case Image::FORMAT_ETC: params+=" format=\"etc\""; break;
case Image::FORMAT_ATC: params+=" format=\"atc\""; break;
case Image::FORMAT_ATC_ALPHA_EXPLICIT: params+=" format=\"atcae\""; break;
case Image::FORMAT_ATC_ALPHA_INTERPOLATED: params+=" format=\"atcai\""; break;
case Image::FORMAT_CUSTOM: params+=" format=\"custom\" custom_size=\""+itos(img.get_data().size())+"\""; break;
default: {}
}
} break;
case Variant::NODE_PATH: type="node_path"; break;
case Variant::OBJECT: {
type="resource";
RES res = p_property;
if (res.is_null()) {
write_tabs();
enter_tag(type,"name=\""+p_name+"\"");
exit_tag(type);
if (r_ok)
*r_ok=true;
return; // don't save it
}
if (external_resources.has(res)) {
params="external=\""+itos(external_resources[res])+"\"";
} else {
params="resource_type=\""+res->get_save_type()+"\"";
if (res->get_path().length() && res->get_path().find("::")==-1) {
//external resource
String path=relative_paths?local_path.path_to_file(res->get_path()):res->get_path();
escape(path);
params+=" path=\""+path+"\"";
} else {
//internal resource
ERR_EXPLAIN("Resource was not pre cached for the resource section, bug?");
ERR_FAIL_COND(!resource_set.has(res));
params+=" path=\"local://"+itos(res->get_subindex())+"\"";
}
}
} break;
case Variant::INPUT_EVENT: type="input_event"; break;
case Variant::DICTIONARY: type="dictionary"; params="shared=\""+String(p_property.is_shared()?"true":"false")+"\""; oneliner=false; break;
case Variant::ARRAY: type="array"; params="len=\""+itos(p_property.operator Array().size())+"\" shared=\""+String(p_property.is_shared()?"true":"false")+"\""; oneliner=false; break;
case Variant::RAW_ARRAY: type="raw_array"; params="len=\""+itos(p_property.operator DVector < uint8_t >().size())+"\""; break;
case Variant::INT_ARRAY: type="int_array"; params="len=\""+itos(p_property.operator DVector < int >().size())+"\""; break;
case Variant::REAL_ARRAY: type="real_array"; params="len=\""+itos(p_property.operator DVector < real_t >().size())+"\""; break;
case Variant::STRING_ARRAY: oneliner=false; type="string_array"; params="len=\""+itos(p_property.operator DVector < String >().size())+"\""; break;
case Variant::VECTOR2_ARRAY: type="vector2_array"; params="len=\""+itos(p_property.operator DVector < Vector2 >().size())+"\""; break;
case Variant::VECTOR3_ARRAY: type="vector3_array"; params="len=\""+itos(p_property.operator DVector < Vector3 >().size())+"\""; break;
case Variant::COLOR_ARRAY: type="color_array"; params="len=\""+itos(p_property.operator DVector < Color >().size())+"\""; break;
default: {
ERR_PRINT("Unknown Variant type.");
ERR_FAIL();
}
}
write_tabs();
if (p_name!="") {
if (params.length())
enter_tag(type,"name=\""+p_name+"\" "+params);
else
enter_tag(type,"name=\""+p_name+"\"");
} else {
if (params.length())
enter_tag(type," "+params);
else
enter_tag(type,String());
}
if (!oneliner)
f->store_8('\n');
else
f->store_8(' ');
switch( p_property.get_type() ) {
case Variant::NIL: {
} break;
case Variant::BOOL: {
write_string( p_property.operator bool() ? "True":"False" );
} break;
case Variant::INT: {
write_string( itos(p_property.operator int()) );
} break;
case Variant::REAL: {
write_string( rtos(p_property.operator real_t()) );
} break;
case Variant::STRING: {
String str=p_property;
escape(str);
str="\""+str+"\"";
write_string( str,false );
} break;
case Variant::VECTOR2: {
Vector2 v = p_property;
write_string( rtoss(v.x) +", "+rtoss(v.y) );
} break;
case Variant::RECT2: {
Rect2 aabb = p_property;
write_string( rtoss(aabb.pos.x) +", "+rtoss(aabb.pos.y) +", "+rtoss(aabb.size.x) +", "+rtoss(aabb.size.y) );
} break;
case Variant::VECTOR3: {
Vector3 v = p_property;
write_string( rtoss(v.x) +", "+rtoss(v.y)+", "+rtoss(v.z) );
} break;
case Variant::PLANE: {
Plane p = p_property;
write_string( rtoss(p.normal.x) +", "+rtoss(p.normal.y)+", "+rtoss(p.normal.z)+", "+rtoss(p.d) );
} break;
case Variant::_AABB: {
AABB aabb = p_property;
write_string( rtoss(aabb.pos.x) +", "+rtoss(aabb.pos.y) +", "+rtoss(aabb.pos.z) +", "+rtoss(aabb.size.x) +", "+rtoss(aabb.size.y) +", "+rtoss(aabb.size.z) );
} break;
case Variant::QUAT: {
Quat quat = p_property;
write_string( rtoss(quat.x)+", "+rtoss(quat.y)+", "+rtoss(quat.z)+", "+rtoss(quat.w)+", ");
} break;
case Variant::MATRIX32: {
String s;
Matrix32 m3 = p_property;
for (int i=0;i<3;i++) {
for (int j=0;j<2;j++) {
if (i!=0 || j!=0)
s+=", ";
s+=rtoss( m3.elements[i][j] );
}
}
write_string(s);
} break;
case Variant::MATRIX3: {
String s;
Matrix3 m3 = p_property;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++) {
if (i!=0 || j!=0)
s+=", ";
s+=rtoss( m3.elements[i][j] );
}
}
write_string(s);
} break;
case Variant::TRANSFORM: {
String s;
Transform t = p_property;
Matrix3 &m3 = t.basis;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++) {
if (i!=0 || j!=0)
s+=", ";
s+=rtoss( m3.elements[i][j] );
}
}
s=s+", "+rtoss(t.origin.x) +", "+rtoss(t.origin.y)+", "+rtoss(t.origin.z);
write_string(s);
} break;
// misc types
case Variant::COLOR: {
Color c = p_property;
write_string( rtoss(c.r) +", "+rtoss(c.g)+", "+rtoss(c.b)+", "+rtoss(c.a) );
} break;
case Variant::IMAGE: {
String s;
Image img = p_property;
DVector<uint8_t> data = img.get_data();
int len = data.size();
DVector<uint8_t>::Read r = data.read();
const uint8_t *ptr=r.ptr();;
for (int i=0;i<len;i++) {
uint8_t byte = ptr[i];
const char hex[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char str[3]={ hex[byte>>4], hex[byte&0xF], 0};
s+=str;
}
write_string(s);
} break;
case Variant::NODE_PATH: {
String str=p_property;
escape(str);
str="\""+str+"\"";
write_string( str,false);
} break;
case Variant::OBJECT: {
/* this saver does not save resources in here
RES res = p_property;
if (!res.is_null()) {
String path=res->get_path();
if (!res->is_shared() || !path.length()) {
// if no path, or path is from inside a scene
write_object( *res );
}
}
*/
} break;
case Variant::INPUT_EVENT: {
write_string( p_property.operator String() );
} break;
case Variant::DICTIONARY: {
Dictionary dict = p_property;
List<Variant> keys;
dict.get_key_list(&keys);
keys.sort();
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
//if (!_check_type(dict[E->get()]))
// continue;
bool ok;
write_property("",E->get(),&ok);
ERR_CONTINUE(!ok);
write_property("",dict[E->get()],&ok);
if (!ok)
write_property("",Variant()); //at least make the file consistent..
}
} break;
case Variant::ARRAY: {
Array array = p_property;
int len=array.size();
for (int i=0;i<len;i++) {
write_property("",array[i]);
}
} break;
case Variant::RAW_ARRAY: {
String s;
DVector<uint8_t> data = p_property;
int len = data.size();
DVector<uint8_t>::Read r = data.read();
const uint8_t *ptr=r.ptr();;
for (int i=0;i<len;i++) {
uint8_t byte = ptr[i];
const char hex[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char str[3]={ hex[byte>>4], hex[byte&0xF], 0};
s+=str;
}
write_string(s,false);
} break;
case Variant::INT_ARRAY: {
DVector<int> data = p_property;
int len = data.size();
DVector<int>::Read r = data.read();
const int *ptr=r.ptr();;
write_tabs();
for (int i=0;i<len;i++) {
if (i>0)
write_string(", ",false);
write_string(itos(ptr[i]),false);
}
} break;
case Variant::REAL_ARRAY: {
DVector<real_t> data = p_property;
int len = data.size();
DVector<real_t>::Read r = data.read();
const real_t *ptr=r.ptr();;
write_tabs();
String cm=", " ;
for (int i=0;i<len;i++) {
if (i>0)
write_string(cm,false);
write_string(rtoss(ptr[i]),false);
}
} break;
case Variant::STRING_ARRAY: {
DVector<String> data = p_property;
int len = data.size();
DVector<String>::Read r = data.read();
const String *ptr=r.ptr();;
String s;
//write_string("\n");
for (int i=0;i<len;i++) {
write_tabs(0);
String str=ptr[i];
escape(str);
write_string("<string> \""+str+"\" </string>\n",false);
}
} break;
case Variant::VECTOR2_ARRAY: {
DVector<Vector2> data = p_property;
int len = data.size();
DVector<Vector2>::Read r = data.read();
const Vector2 *ptr=r.ptr();;
write_tabs();
for (int i=0;i<len;i++) {
if (i>0)
write_string(", ",false);
write_string(rtoss(ptr[i].x),false);
write_string(", "+rtoss(ptr[i].y),false);
}
} break;
case Variant::VECTOR3_ARRAY: {
DVector<Vector3> data = p_property;
int len = data.size();
DVector<Vector3>::Read r = data.read();
const Vector3 *ptr=r.ptr();;
write_tabs();
for (int i=0;i<len;i++) {
if (i>0)
write_string(", ",false);
write_string(rtoss(ptr[i].x),false);
write_string(", "+rtoss(ptr[i].y),false);
write_string(", "+rtoss(ptr[i].z),false);
}
} break;
case Variant::COLOR_ARRAY: {
DVector<Color> data = p_property;
int len = data.size();
DVector<Color>::Read r = data.read();
const Color *ptr=r.ptr();;
write_tabs();
for (int i=0;i<len;i++) {
if (i>0)
write_string(", ",false);
write_string(rtoss(ptr[i].r),false);
write_string(", "+rtoss(ptr[i].g),false);
write_string(", "+rtoss(ptr[i].b),false);
write_string(", "+rtoss(ptr[i].a),false);
}
} break;
default: {}
}
if (oneliner)
f->store_8(' ');
else
write_tabs(-1);
exit_tag(type);
f->store_8('\n');
if (r_ok)
*r_ok=true;
}
void ResourceFormatSaverXMLInstance::_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() || external_resources.has(res))
return;
if (!p_main && (!bundle_resources ) && res->get_path().length() && res->get_path().find("::") == -1 ) {
int index = external_resources.size();
external_resources[res]=index;
return;
}
if (resource_set.has(res))
return;
List<PropertyInfo> property_list;
res->get_property_list( &property_list );
property_list.sort();
List<PropertyInfo>::Element *I=property_list.front();
while(I) {
PropertyInfo pi=I->get();
if (pi.usage&PROPERTY_USAGE_STORAGE || (bundle_resources && pi.usage&PROPERTY_USAGE_BUNDLE)) {
Variant v=res->get(I->get().name);
_find_resources(v);
}
I=I->next();
}
resource_set.insert( res ); //saved after, so the childs it needs are available when loaded
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()) {
Variant v = d[E->get()];
_find_resources(v);
}
} break;
default: {}
}
}
Error ResourceFormatSaverXMLInstance::save(const String &p_path,const RES& p_resource,uint32_t p_flags) {
Error err;
f = FileAccess::open(p_path, FileAccess::WRITE,&err);
ERR_FAIL_COND_V( err, ERR_CANT_OPEN );
FileAccessRef _fref(f);
local_path = Globals::get_singleton()->localize_path(p_path);
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;
takeover_paths=p_flags&ResourceSaver::FLAG_REPLACE_SUBRESOURCE_PATHS;
if (!p_path.begins_with("res://")) {
takeover_paths=false;
}
depth=0;
// save resources
_find_resources(p_resource,true);
ERR_FAIL_COND_V(err!=OK,err);
write_string("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>",false); //no escape
write_string("\n",false);
enter_tag("resource_file","type=\""+p_resource->get_type()+"\" subresource_count=\""+itos(saved_resources.size()+external_resources.size())+"\" version=\""+itos(VERSION_MAJOR)+"."+itos(VERSION_MINOR)+"\" version_name=\""+VERSION_FULL_NAME+"\"");
write_string("\n",false);
for(Map<RES,int>::Element *E=external_resources.front();E;E=E->next()) {
write_tabs();
String p = E->key()->get_path();
enter_tag("ext_resource","path=\""+p+"\" type=\""+E->key()->get_save_type()+"\" index=\""+itos(E->get())+"\""); //bundled
exit_tag("ext_resource"); //bundled
write_string("\n",false);
}
Set<int> used_indices;
for(List<RES>::Element *E=saved_resources.front();E;E=E->next()) {
RES res = E->get();
if (E->next() && (res->get_path()=="" || res->get_path().find("::") != -1 )) {
if (res->get_subindex()!=0) {
if (used_indices.has(res->get_subindex())) {
res->set_subindex(0); //repeated
} else {
used_indices.insert(res->get_subindex());
}
}
}
}
for(List<RES>::Element *E=saved_resources.front();E;E=E->next()) {
RES res = E->get();
ERR_CONTINUE(!resource_set.has(res));
bool main = (E->next()==NULL);
write_tabs();
if (main)
enter_tag("main_resource",""); //bundled
else if (res->get_path().length() && res->get_path().find("::") == -1 )
enter_tag("resource","type=\""+res->get_type()+"\" path=\""+res->get_path()+"\""); //bundled
else {
if (res->get_subindex()==0) {
int new_subindex=1;
if (used_indices.size()) {
new_subindex=used_indices.back()->get()+1;
}
res->set_subindex(new_subindex);
used_indices.insert(new_subindex);
}
int idx = res->get_subindex();
enter_tag("resource","type=\""+res->get_type()+"\" path=\"local://"+itos(idx)+"\"");
if (takeover_paths) {
res->set_path(p_path+"::"+itos(idx),true);
}
}
write_string("\n",false);
List<PropertyInfo> property_list;
res->get_property_list(&property_list);
// property_list.sort();
for(List<PropertyInfo>::Element *PE = property_list.front();PE;PE=PE->next()) {
if (skip_editor && PE->get().name.begins_with("__editor"))
continue;
if (PE->get().usage&PROPERTY_USAGE_STORAGE || (bundle_resources && PE->get().usage&PROPERTY_USAGE_BUNDLE)) {
String name = PE->get().name;
Variant value = res->get(name);
if ((PE->get().usage&PROPERTY_USAGE_STORE_IF_NONZERO && value.is_zero())||(PE->get().usage&PROPERTY_USAGE_STORE_IF_NONONE && value.is_one()) )
continue;
write_property(name,value);
}
}
write_string("\n",false);
write_tabs(-1);
if (main)
exit_tag("main_resource");
else
exit_tag("resource");
write_string("\n",false);
}
exit_tag("resource_file");
if (f->get_error()!=OK && f->get_error()!=ERR_FILE_EOF) {
f->close();
return ERR_CANT_CREATE;
}
f->close();
//memdelete(f);
return OK;
}
Error ResourceFormatSaverXML::save(const String &p_path,const RES& p_resource,uint32_t p_flags) {
ResourceFormatSaverXMLInstance saver;
return saver.save(p_path,p_resource,p_flags);
}
bool ResourceFormatSaverXML::recognize(const RES& p_resource) const {
return true; // all recognized!
}
void ResourceFormatSaverXML::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();
p_extensions->push_back("xml");
if (base!="res") {
p_extensions->push_back("x"+base);
}
}
ResourceFormatSaverXML* ResourceFormatSaverXML::singleton=NULL;
ResourceFormatSaverXML::ResourceFormatSaverXML() {
singleton=this;
}
Reference in a new issue View git blame Copy permalink