text: /*************************************************************************/
  /*  resource_loader.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 "resource_loader.h"
  #include "print_string.h"
  #include "globals.h"
  #include "path_remap.h"
  #include "os/file_access.h"
  #include "os/os.h"
  ResourceFormatLoader *ResourceLoader::loader[MAX_LOADERS];
  
  int ResourceLoader::loader_count=0;
  
  
  Error ResourceInteractiveLoader::wait() {
  
  	Error err = poll();
  	while (err==OK) {
  		err=poll();
  	}
  
  	return err;
  }
  
  
  bool ResourceFormatLoader::recognize(const String& p_extension) const {
  	
  	
  	List<String> extensions;
  	get_recognized_extensions(&extensions);
  	for (List<String>::Element *E=extensions.front();E;E=E->next()) {
  		
  		if (E->get().nocasecmp_to(p_extension.extension())==0)
  			return true;
  	}
  	
  	return false;
  }
  
  void ResourceFormatLoader::get_recognized_extensions_for_type(const String& p_type,List<String> *p_extensions) const {
  
  	if (p_type=="" || handles_type(p_type))
  		get_recognized_extensions(p_extensions);
  }
  
  void ResourceLoader::get_recognized_extensions_for_type(const String& p_type,List<String> *p_extensions) {
  
  	for (int i=0;i<loader_count;i++) {
  		loader[i]->get_recognized_extensions_for_type(p_type,p_extensions);
  	}
  
  }
  
  void ResourceInteractiveLoader::_bind_methods() {
  
  	ObjectTypeDB::bind_method(_MD("get_resource"),&ResourceInteractiveLoader::get_resource);
  	ObjectTypeDB::bind_method(_MD("poll"),&ResourceInteractiveLoader::poll);
  	ObjectTypeDB::bind_method(_MD("wait"),&ResourceInteractiveLoader::wait);
  	ObjectTypeDB::bind_method(_MD("get_stage"),&ResourceInteractiveLoader::get_stage);
  	ObjectTypeDB::bind_method(_MD("get_stage_count"),&ResourceInteractiveLoader::get_stage_count);
  }
  
  class ResourceInteractiveLoaderDefault : public ResourceInteractiveLoader {
  
  	OBJ_TYPE( ResourceInteractiveLoaderDefault, ResourceInteractiveLoader );
  public:
  
  	Ref<Resource> resource;
  
  	virtual void set_local_path(const String& p_local_path) { /*scene->set_filename(p_local_path);*/ }
  	virtual Ref<Resource> get_resource() { return resource; }
  	virtual Error poll() { return ERR_FILE_EOF; }
  	virtual int get_stage() const { return 1; }
  	virtual int get_stage_count() const { return 1; }
  
  	ResourceInteractiveLoaderDefault() {}
  };
  
  
  
  Ref<ResourceInteractiveLoader> ResourceFormatLoader::load_interactive(const String &p_path) {
  
  	//either this
  	Ref<Resource> res = load(p_path);
  	if (res.is_null())
  		return Ref<ResourceInteractiveLoader>();
  
  	Ref<ResourceInteractiveLoaderDefault> ril = Ref<ResourceInteractiveLoaderDefault>( memnew( ResourceInteractiveLoaderDefault ));
  	ril->resource=res;
  	return ril;
  }
  
  RES ResourceFormatLoader::load(const String &p_path,const String& p_original_path) {
  
  
  	//or this must be implemented
  	Ref<ResourceInteractiveLoader> ril = load_interactive(p_path);
  	if (!ril.is_valid())
  		return RES();
  	ril->set_local_path(p_original_path);
  
  	while(true) {
  
  		Error err = ril->poll();
  
  		if (err==ERR_FILE_EOF) {
  			return ril->get_resource();
  		}
  
  		ERR_FAIL_COND_V(err!=OK,RES());
  	}
  
  	return RES();
  
  }
  
  void ResourceFormatLoader::get_dependencies(const String& p_path,List<String> *p_dependencies) {
  
  	//do nothing by default
  }
  
  
  ///////////////////////////////////
  
  
  RES ResourceLoader::load(const String &p_path,const String& p_type_hint,bool p_no_cache) {
  
  	String local_path = Globals::get_singleton()->localize_path(p_path);
  
  	local_path=find_complete_path(p_path,p_type_hint);
  	ERR_FAIL_COND_V(local_path=="",RES());
  
  	if (!p_no_cache && ResourceCache::has(local_path)) {
  
  		if (OS::get_singleton()->is_stdout_verbose())
  			print_line("load resource: "+local_path+" (cached)");
  
  		return RES( ResourceCache::get(local_path ) );
  	}
  
  	String remapped_path = PathRemap::get_singleton()->get_remap(local_path);
  
  	if (OS::get_singleton()->is_stdout_verbose())
  		print_line("load resource: "+remapped_path);
  
  	String extension=remapped_path.extension();
  	bool found=false;
  	
  	for (int i=0;i<loader_count;i++) {
  		
  		if (!loader[i]->recognize(extension))
  			continue;
  		if (p_type_hint!="" && !loader[i]->handles_type(p_type_hint))
  			continue;
  		found=true;
  		RES res = loader[i]->load(remapped_path,local_path);
  		if (res.is_null())
  			continue;
  		if (!p_no_cache)
  			res->set_path(local_path);
  #ifdef TOOLS_ENABLED
  
  		res->set_edited(false);
  		if (timestamp_on_load) {
  			uint64_t mt = FileAccess::get_modified_time(remapped_path);
  			//printf("mt %s: %lli\n",remapped_path.utf8().get_data(),mt);
  			res->set_last_modified_time(mt);
  		}
  #endif
  
  		return res;
  	}
  
  	if (found) {
  		ERR_EXPLAIN("Failed loading resource: "+p_path);
  	} else {
  		ERR_EXPLAIN("No loader found for resource: "+p_path);
  	}
  	ERR_FAIL_V(RES());
  	return RES();
  }
  
  
  Ref<ResourceImportMetadata> ResourceLoader::load_import_metadata(const String &p_path) {
  
  
  	String local_path = Globals::get_singleton()->localize_path(p_path);
  
  	String extension=p_path.extension();
  	bool found=false;
  	Ref<ResourceImportMetadata> ret;
  
  	for (int i=0;i<loader_count;i++) {
  
  		if (!loader[i]->recognize(extension))
  			continue;
  		found=true;
  
  		Error err = loader[i]->load_import_metadata(local_path,ret);
  		if (err==OK)
  			break;
  	}
  
  	return ret;
  
  }
  
  
  
  String ResourceLoader::find_complete_path(const String& p_path,const String& p_type) {
  	//this is an old vestige when the engine saved files without extension.
  	//remains here for compatibility with old projects and only because it
  	//can be sometimes nice to open files using .* from a script and have it guess
  	//the right extension.
  
  	String local_path = p_path;
  	if (local_path.ends_with("*")) {
  
  		//find the extension for resource that ends with *
  		local_path = local_path.substr(0,local_path.length()-1);
  		List<String> extensions;
  		get_recognized_extensions_for_type(p_type,&extensions);
  		List<String> candidates;
  
  		for(List<String>::Element *E=extensions.front();E;E=E->next()) {
  
  			String path = local_path+E->get();
  
  			if (PathRemap::get_singleton()->has_remap(path) || FileAccess::exists(path)) {
  				candidates.push_back(path);
  			}
  
  		}
  
  
  		if (candidates.size()==0) {
  			return "";
  		} else if (candidates.size()==1 || p_type=="") {
  			return candidates.front()->get();
  		} else {
  
  			for(List<String>::Element *E=candidates.front();E;E=E->next()) {
  
  				String rt = get_resource_type(E->get());
  				if (ObjectTypeDB::is_type(rt,p_type)) {
  					return E->get();
  				}
  			}
  
  			return "";
  		}
  	}
  
  	return local_path;
  }
  
  Ref<ResourceInteractiveLoader> ResourceLoader::load_interactive(const String &p_path,const String& p_type_hint,bool p_no_cache) {
  
  
  
  	String local_path = Globals::get_singleton()->localize_path(p_path);
  
  	local_path=find_complete_path(p_path,p_type_hint);
  	ERR_FAIL_COND_V(local_path=="",Ref<ResourceInteractiveLoader>());
  
  
  
  	if (!p_no_cache && ResourceCache::has(local_path)) {
  
  		if (OS::get_singleton()->is_stdout_verbose())
  			print_line("load resource: "+local_path+" (cached)");
  
  		return RES( ResourceCache::get(local_path ) );
  	}
  
  	if (OS::get_singleton()->is_stdout_verbose())
  		print_line("load resource: ");
  
  	String remapped_path = PathRemap::get_singleton()->get_remap(local_path);
  
  	String extension=remapped_path.extension();
  	bool found=false;
  
  	for (int i=0;i<loader_count;i++) {
  
  		if (!loader[i]->recognize(extension))
  			continue;
  		if (p_type_hint!="" && !loader[i]->handles_type(p_type_hint))
  			continue;
  		found=true;
  		Ref<ResourceInteractiveLoader> ril = loader[i]->load_interactive(remapped_path);
  		if (ril.is_null())
  			continue;
  		if (!p_no_cache)
  			ril->set_local_path(local_path);
  
  		return ril;
  	}
  
  	if (found) {
  		ERR_EXPLAIN("Failed loading resource: "+p_path);
  	} else {
  		ERR_EXPLAIN("No loader found for resource: "+p_path);
  	}
  	ERR_FAIL_V(Ref<ResourceInteractiveLoader>());
  	return Ref<ResourceInteractiveLoader>();
  
  }
  
  void ResourceLoader::add_resource_format_loader(ResourceFormatLoader *p_format_loader) {
  	
  	ERR_FAIL_COND( loader_count >= MAX_LOADERS );
  	loader[loader_count++]=p_format_loader;
  }
  
  void ResourceLoader::get_dependencies(const String& p_path,List<String> *p_dependencies) {
  
  	String local_path = Globals::get_singleton()->localize_path(p_path);
  	String remapped_path = PathRemap::get_singleton()->get_remap(local_path);
  
  	String extension=remapped_path.extension();
  
  	for (int i=0;i<loader_count;i++) {
  
  		if (!loader[i]->recognize(extension))
  			continue;
  		//if (p_type_hint!="" && !loader[i]->handles_type(p_type_hint))
  		//	continue;
  
  		loader[i]->get_dependencies(remapped_path,p_dependencies);
  
  	}
  }
  
  String ResourceLoader::guess_full_filename(const String &p_path,const String& p_type) {
  
  	String local_path = Globals::get_singleton()->localize_path(p_path);
  
  	return find_complete_path(local_path,p_type);
  
  }
  
  String ResourceLoader::get_resource_type(const String &p_path) {
  
  	String local_path = Globals::get_singleton()->localize_path(p_path);
  	String remapped_path = PathRemap::get_singleton()->get_remap(local_path);
  	String extension=remapped_path.extension();
  
  	bool found=false;
  	for (int i=0;i<loader_count;i++) {
  
  		String result = loader[i]->get_resource_type(local_path);
  		if (result!="")
  			return result;
  	}
  
  	return "";
  
  }
  ResourceLoadErrorNotify ResourceLoader::err_notify=NULL;
  void *ResourceLoader::err_notify_ud=NULL;
  
  bool ResourceLoader::abort_on_missing_resource=true;
  bool ResourceLoader::timestamp_on_load=false;
  
  