* Interface for textures, sounds, and other types of resources.
*/
-#include "../config.h"
+#include "config.h"
#include <cstdio>
#include <map>
{
public:
- // FIXME: this won't be necessary once the existing code is modified to
+ // XXX: this won't be necessary once the existing code is modified to
// use the resource handles
resource() {}
* \param path The name of the resource to find. Upon successful
* return, this is changed to an absolute path to the resource.
* \return True if a path to a resource was found, false otherwise.
+ * XXX this is legacy
*/
static bool find(const std::string& file);
+ static std::string find_file(const std::string& name);
+
+ static std::string find_file(const std::string& name,
+ const std::string& ext);
+
/**
* Get the path to a resource of a given name and open it if a resource
* was found.
* return, this is changed to an absolute path to the resource.
* \param mode The open mode.
* \return The FILE* if the resource was found, 0 otherwise.
+ * XXX deprecated
*/
static FILE* open_file(const std::string& path,
const std::string& mode = "rb");
* \param extension The file extension.
*/
template <class T>
- static void register_type(const std::string& extension)
+ static void register_type(const std::string& extension,
+ const std::string& prefix = "")
{
- if (!type_lookup_) type_lookup_ = type_lookup_ptr(new type_lookup);
- loader_ptr loader(new specific_loader<T>);
- (*type_lookup_)[extension] = loader;
+ loader_ptr loader(new specific_loader<T>(prefix));
+ printf("registered type with prefix %s", loader->prefix().c_str());
+ call_registry(extension, loader, set);
}
/**
*/
static void unregister_type(const std::string& extension)
{
- type_lookup_->erase(extension);
+ loader_ptr loader;
+ call_registry(extension, loader, set);
}
- static resource_ptr load(const std::string& path);
+ static resource_ptr load(const std::string& name);
+ static resource_ptr load(const std::string& name,
+ const std::string& ext);
static resource_ptr reload(std::string& path);
private:
+ static resource_ptr load_with_path(const std::string& path);
+
class loader
{
public:
+ //loader() {}
+ loader(const std::string& prefix) :
+ prefix_(prefix) {}
+
virtual ~loader() {}
virtual resource* load(const std::string& path)
{
return 0;
}
+
+ const std::string& prefix() const
+ {
+ return prefix_;
+ }
+
+
+ private:
+
+ std::string prefix_;
};
typedef boost::shared_ptr<loader> loader_ptr;
{
public:
+ //specific_loader() {}
+ specific_loader(const std::string& prefix) :
+ loader(prefix) {}
+
virtual resource* load(const std::string& path)
{
+ log_info("loading resource of type ", typeid(T).name());
return new resource(new T(path));
}
};
virtual ~specific_unloader()
{
- log_warning("unloading resource of type ", typeid(T).name());
+ log_info("unloading resource of type ", typeid(T).name());
delete object_;
}
loader_ptr loader_;
typedef std::map<std::string,loader_ptr> type_lookup;
- typedef boost::shared_ptr<type_lookup> type_lookup_ptr;
- static type_lookup_ptr type_lookup_;
+ //typedef boost::shared_ptr<type_lookup> type_lookup_ptr;
+ //static type_lookup_ptr type_lookup_;
+ //static type_lookup type_lookup_;
+
+ enum registry_action
+ {
+ lookup,
+ set
+ };
+
+ static bool call_registry(const std::string& extension,
+ loader_ptr& loader,
+ registry_action action);
#ifdef USE_HOTLOADING
int wd_;
resource_handle(resource_ptr ptr) :
resource_(ptr) {}
+ explicit resource_handle(const std::string& name) :
+ resource_(resource::load(name)) {}
+
+ resource_handle(const std::string& name, const std::string& ext) :
+ resource_(resource::load(name, ext)) {}
+
+
/**
* Get whether or not the handle is dereferenceable to the type of this
}
+ /**
+ * Unload the resource associated with this handle.
+ */
+ void unload()
+ {
+ resource_ = resource_ptr();
+ }
+
+
private:
resource_ptr resource_;