Cleanup

src/resource/package_resource.cpp

@@ -10,6 +10,7 @@
 #include "temp_allocator.h"
 #include "reader_writer.h"
 #include "compile_options.h"
+#include "array.h"
 
 namespace crown
 {
@@ -49,277 +50,127 @@ namespace package_resource
 		const uint32_t num_shaders   = shader.is_nil() ? 0 : shader.size();
 		const uint32_t num_sprite_animations = sprite_animation.is_nil() ? 0 : sprite_animation.size();
 
+		Array<PackageResource::Resource> resources(default_allocator());
+
+		for (uint32_t i = 0; i < num_textures; ++i)
+		{
+			PackageResource::Resource res(TEXTURE_TYPE, texture[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_scripts; ++i)
+		{
+			PackageResource::Resource res(SCRIPT_TYPE, script[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_sounds; ++i)
+		{
+			PackageResource::Resource res(SOUND_TYPE, sound[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_meshes; ++i)
+		{
+			PackageResource::Resource res(MESH_TYPE, mesh[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_units; ++i)
+		{
+			PackageResource::Resource res(UNIT_TYPE, unit[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_sprites; ++i)
+		{
+			PackageResource::Resource res(SPRITE_TYPE, sprite[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_physics; ++i)
+		{
+			PackageResource::Resource res(PHYSICS_TYPE, physics[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_materials; ++i)
+		{
+			PackageResource::Resource res(MATERIAL_TYPE, material[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_fonts; ++i)
+		{
+			PackageResource::Resource res(FONT_TYPE, font[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_levels; ++i)
+		{
+			PackageResource::Resource res(LEVEL_TYPE, level[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_phyconfs; ++i)
+		{
+			PackageResource::Resource res(PHYSICS_CONFIG_TYPE, phyconf[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_shaders; ++i)
+		{
+			PackageResource::Resource res(SHADER_TYPE, shader[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
+		for (uint32_t i = 0; i < num_sprite_animations; ++i)
+		{
+			PackageResource::Resource res(SPRITE_ANIMATION_TYPE, sprite_animation[i].to_resource_id());
+			array::push_back(resources, res);
+		}
+
 		// Write header
 		opts.write(PACKAGE_VERSION);
-		opts.write(num_textures);
-		uint32_t offt = sizeof(PackageResource);
-		opts.write(offt);
-
-		opts.write(num_scripts);
-		offt += sizeof(StringId64) * num_textures;
-		opts.write(offt);
-
-		opts.write(num_sounds);
-		offt += sizeof(StringId64) * num_scripts;
-		opts.write(offt);
-
-		opts.write(num_meshes);
-		offt += sizeof(StringId64) * num_sounds;
-		opts.write(offt);
-
-		opts.write(num_units);
-		offt += sizeof(StringId64) * num_meshes;
-		opts.write(offt);
-
-		opts.write(num_sprites);
-		offt += sizeof(StringId64) * num_units;
-		opts.write(offt);
-
-		opts.write(num_physics);
-		offt += sizeof(StringId64) * num_sprites;
-		opts.write(offt);
-
-		opts.write(num_materials);
-		offt += sizeof(StringId64) * num_physics;
-		opts.write(offt);
-
-		opts.write(num_fonts);
-		offt += sizeof(StringId64) * num_materials;
-		opts.write(offt);
-
-		opts.write(num_levels);
-		offt += sizeof(StringId64) * num_fonts;
-		opts.write(offt);
-
-		opts.write(num_phyconfs);
-		offt += sizeof(StringId64) * num_levels;
-		opts.write(offt);
-
-		opts.write(num_shaders);
-		offt += sizeof(StringId64) * num_phyconfs;
-		opts.write(offt);
-
-		opts.write(num_sprite_animations);
-		offt += sizeof(StringId64) * num_shaders;
-		opts.write(offt);
+		opts.write(array::size(resources));
 
 		// Write resource ids
-		for (uint32_t i = 0; i < num_textures; i++)
-			opts.write(texture[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_scripts; i++)
-			opts.write(script[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_sounds; i++)
-			opts.write(sound[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_meshes; i++)
-			opts.write(mesh[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_units; i++)
-			opts.write(unit[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_sprites; i++)
-			opts.write(sprite[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_physics; i++)
-			opts.write(physics[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_materials; i++)
-			opts.write(material[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_fonts; i++)
-			opts.write(font[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_levels; i++)
-			opts.write(level[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_phyconfs; i++)
-			opts.write(phyconf[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_shaders; i++)
-			opts.write(shader[i].to_resource_id());
-
-		for (uint32_t i = 0; i < num_sprite_animations; i++)
-			opts.write(sprite_animation[i].to_resource_id());
+		for (uint32_t i = 0; i < array::size(resources); ++i)
+		{
+			opts.write(resources[i].type);
+			opts.write(resources[i].name);
+		}
 	}
 
 	void* load(File& file, Allocator& a)
 	{
-		const uint32_t file_size = file.size();
-		void* res = a.allocate(file_size);
-		file.read(res, file_size);
-		CE_ASSERT(*(uint32_t*)res == PACKAGE_VERSION, "Wrong version");
-		return res;
-	}
-
-	void online(StringId64 /*id*/, ResourceManager& /*rm*/)
-	{
-	}
-
-	void offline(StringId64 /*id*/, ResourceManager& /*rm*/)
-	{
-	}
-
-	void unload(Allocator& allocator, void* resource)
-	{
-		allocator.deallocate(resource);
-	}
-
-	uint32_t num_textures(const PackageResource* pr)
-	{
-		return pr->num_textures;
-	}
+		BinaryReader br(file);
 
-	uint32_t num_scripts(const PackageResource* pr)
-	{
-		return pr->num_scripts;
-	}
+		uint32_t version;
+		br.read(version);
+		CE_ASSERT(version == PACKAGE_VERSION, "Wrong version");
 
-	uint32_t num_sounds(const PackageResource* pr)
-	{
-		return pr->num_sounds;
-	}
+		uint32_t num_resources;
+		br.read(num_resources);
 
-	uint32_t num_meshes(const PackageResource* pr)
-	{
-		return pr->num_meshes;
-	}
+		PackageResource* pr = CE_NEW(a, PackageResource)(a);
+		array::resize(pr->resources, num_resources);
+		br.read(array::begin(pr->resources), sizeof(PackageResource::Resource)*num_resources);
 
-	uint32_t num_units(const PackageResource* pr)
-	{
-		return pr->num_units;
-	}
-
-	uint32_t num_sprites(const PackageResource* pr)
-	{
-		return pr->num_sprites;
+		return pr;
 	}
 
-	uint32_t num_physics(const PackageResource* pr)
-	{
-		return pr->num_physics;
-	}
-
-	uint32_t num_materials(const PackageResource* pr)
-	{
-		return pr->num_materials;
-	}
-
-	uint32_t num_fonts(const PackageResource* pr)
-	{
-		return pr->num_fonts;
-	}
-
-	uint32_t num_levels(const PackageResource* pr)
-	{
-		return pr->num_levels;
-	}
-
-	uint32_t num_physics_configs(const PackageResource* pr)
-	{
-		return pr->num_physics_configs;
-	}
-
-	uint32_t num_shaders(const PackageResource* pr)
-	{
-		return pr->num_shaders;
-	}
-
-	uint32_t num_sprite_animations(const PackageResource* pr)
-	{
-		return pr->num_sprite_animations;
-	}
-
-	StringId64 get_texture_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_textures(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->textures_offset);
-		return begin[i];
-	}
-
-	StringId64 get_script_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_scripts(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->scripts_offset);
-		return begin[i];
-	}
-
-	StringId64 get_sound_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_sounds(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->sounds_offset);
-		return begin[i];
-	}
-
-	StringId64 get_mesh_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_meshes(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->meshes_offset);
-		return begin[i];
-	}
-
-	StringId64 get_unit_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_units(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->units_offset);
-		return begin[i];
-	}
-
-	StringId64 get_sprite_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_sprites(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->sprites_offset);
-		return begin[i];
-	}
-
-	StringId64 get_physics_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_physics(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->physics_offset);
-		return begin[i];
-	}
-
-	StringId64 get_material_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_materials(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->materials_offset);
-		return begin[i];
-	}
-
-	StringId64 get_font_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_fonts(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->fonts_offset);
-		return begin[i];
-	}
-
-	StringId64 get_level_id(const PackageResource* pr, uint32_t i)
-	{
-		CE_ASSERT(i < num_levels(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->levels_offset);
-		return begin[i];
-	}
-
-	StringId64 get_physics_config_id(const PackageResource* pr, uint32_t i)
+	void online(StringId64 /*id*/, ResourceManager& /*rm*/)
 	{
-		CE_ASSERT(i < num_physics_configs(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->physics_configs_offset);
-		return begin[i];
 	}
 
-	StringId64 get_shader_id(const PackageResource* pr, uint32_t i)
+	void offline(StringId64 /*id*/, ResourceManager& /*rm*/)
 	{
-		CE_ASSERT(i < num_shaders(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->shaders_offset);
-		return begin[i];
 	}
 
-	StringId64 get_sprite_animation_id(const PackageResource* pr, uint32_t i)
+	void unload(Allocator& a, void* resource)
 	{
-		CE_ASSERT(i < num_sprite_animations(pr), "Index out of bounds");
-		StringId64* begin = (StringId64*) ((char*)pr + pr->sprite_animations_offset);
-		return begin[i];
+		CE_DELETE(a, (PackageResource*)resource);
 	}
 } // namespace package_resource
 } // namespace crown

src/resource/package_resource.h

@@ -9,39 +9,41 @@
 #include "resource_types.h"
 #include "filesystem_types.h"
 #include "compiler_types.h"
+#include "container_types.h"
 
 namespace crown
 {
 
 struct PackageResource
 {
-	uint32_t version;
-	uint32_t num_textures;
-	uint32_t textures_offset;
-	uint32_t num_scripts;
-	uint32_t scripts_offset;
-	uint32_t num_sounds;
-	uint32_t sounds_offset;
-	uint32_t num_meshes;
-	uint32_t meshes_offset;
-	uint32_t num_units;
-	uint32_t units_offset;
-	uint32_t num_sprites;
-	uint32_t sprites_offset;
-	uint32_t num_physics;
-	uint32_t physics_offset;
-	uint32_t num_materials;
-	uint32_t materials_offset;
-	uint32_t num_fonts;
-	uint32_t fonts_offset;
-	uint32_t num_levels;
-	uint32_t levels_offset;
-	uint32_t num_physics_configs;
-	uint32_t physics_configs_offset;
-	uint32_t num_shaders;
-	uint32_t shaders_offset;
-	uint32_t num_sprite_animations;
-	uint32_t sprite_animations_offset;
+	struct Resource
+	{
+		StringId64 type;
+		StringId64 name;
+
+		Resource(StringId64 t, StringId64 n)
+			: type(t)
+			, name(n)
+		{
+		}
+
+		bool operator<(const Resource& r) const
+		{
+			return type < r.type;
+		}
+
+		bool operator==(const Resource& r) const
+		{
+			return type == r.type && name == r.name;
+		}
+	};
+
+	PackageResource(Allocator& a)
+		: resources(a)
+	{
+	}
+
+	Array<Resource> resources;
 };
 
 namespace package_resource
@@ -51,32 +53,5 @@ namespace package_resource
 	void online(StringId64 /*id*/, ResourceManager& /*rm*/);
 	void offline(StringId64 /*id*/, ResourceManager& /*rm*/);
 	void unload(Allocator& allocator, void* resource);
-
-	uint32_t num_textures(const PackageResource* pr);
-	uint32_t num_scripts(const PackageResource* pr);
-	uint32_t num_sounds(const PackageResource* pr);
-	uint32_t num_meshes(const PackageResource* pr);
-	uint32_t num_units(const PackageResource* pr);
-	uint32_t num_sprites(const PackageResource* pr);
-	uint32_t num_physics(const PackageResource* pr);
-	uint32_t num_materials(const PackageResource* pr);
-	uint32_t num_fonts(const PackageResource* pr);
-	uint32_t num_levels(const PackageResource* pr);
-	uint32_t num_physics_configs(const PackageResource* pr);
-	uint32_t num_shaders(const PackageResource* pr);
-	uint32_t num_sprite_animations(const PackageResource* pr);
-	StringId64 get_texture_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_script_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_sound_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_mesh_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_unit_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_sprite_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_physics_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_material_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_font_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_level_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_physics_config_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_shader_id(const PackageResource* pr, uint32_t i);
-	StringId64 get_sprite_animation_id(const PackageResource* pr, uint32_t i);
 } // namespace package_resource
 } // namespace crown

src/resource/resource_package.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2012-2015 Daniele Bartolini and individual contributors.
+ * License: https://github.com/taylor001/crown/blob/master/LICENSE
+ */
+
+#pragma once
+
+#include "resource_package.h"
+#include "resource_manager.h"
+#include "package_resource.h"
+#include "array.h"
+
+namespace crown
+{
+
+ResourcePackage::ResourcePackage(StringId64 id, ResourceManager& resman)
+	: _marker(MARKER)
+	, _resman(&resman)
+	, _id(id)
+	, _package(NULL)
+{
+	resman.load(PACKAGE_TYPE, _id);
+	resman.flush();
+	_package = (const PackageResource*)resman.get(PACKAGE_TYPE, _id);
+}
+
+ResourcePackage::~ResourcePackage()
+{
+	_resman->unload(PACKAGE_TYPE, _id);
+
+	_marker = 0;
+}
+
+void ResourcePackage::load()
+{
+	for (uint32_t i = 0; i < array::size(_package->resources); ++i)
+	{
+		_resman->load(_package->resources[i].type, _package->resources[i].name);
+	}
+}
+
+void ResourcePackage::unload()
+{
+	for (uint32_t i = 0; i < array::size(_package->resources); ++i)
+	{
+		_resman->unload(_package->resources[i].type, _package->resources[i].name);
+	}
+}
+
+void ResourcePackage::flush()
+{
+	_resman->flush();
+}
+
+bool ResourcePackage::has_loaded() const
+{
+	for (uint32_t i = 0; i < array::size(_package->resources); ++i)
+	{
+		if (!_resman->can_get(_package->resources[i].type, _package->resources[i].name))
+			return false;
+	}
+
+	return true;
+}
+
+} // namespace crown

src/resource/resource_package.h

@@ -6,8 +6,7 @@
 #pragma once
 
 #include "types.h"
-#include "resource_manager.h"
-#include "package_resource.h"
+#include "resource_types.h"
 
 namespace crown
 {
@@ -15,260 +14,32 @@ namespace crown
 /// Collection of resources to load in a batch.
 struct ResourcePackage
 {
-	ResourcePackage(StringId64 id, ResourceManager& resman)
-		: _resman(&resman)
-		, _id(id)
-		, _package(NULL)
-	{
-		resman.load(PACKAGE_TYPE, _id);
-		resman.flush();
-		_package = (const PackageResource*) resman.get(PACKAGE_TYPE, _id);
-	}
-
-	~ResourcePackage()
-	{
-		_resman->unload(PACKAGE_TYPE, _id);
-	}
+	ResourcePackage(StringId64 id, ResourceManager& resman);
+	~ResourcePackage();
 
 	/// Loads all the resources in the package.
 	/// @note
 	/// The resources are not immediately available after the call is made,
 	/// instead, you have to poll for completion with has_loaded()
-	void load()
-	{
-		using namespace package_resource;
-
-		for (uint32_t i = 0; i < num_textures(_package); i++)
-		{
-			_resman->load(TEXTURE_TYPE, get_texture_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_scripts(_package); i++)
-		{
-			_resman->load(SCRIPT_TYPE, get_script_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_sounds(_package); i++)
-		{
-			_resman->load(SOUND_TYPE, get_sound_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_meshes(_package); i++)
-		{
-			_resman->load(MESH_TYPE, get_mesh_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_units(_package); i++)
-		{
-			_resman->load(UNIT_TYPE, get_unit_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_sprites(_package); i++)
-		{
-			_resman->load(SPRITE_TYPE, get_sprite_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_physics(_package); i++)
-		{
-			_resman->load(PHYSICS_TYPE, get_physics_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_materials(_package); i++)
-		{
-			_resman->load(MATERIAL_TYPE, get_material_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_fonts(_package); i++)
-		{
-			_resman->load(FONT_TYPE, get_font_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_levels(_package); i++)
-		{
-			_resman->load(LEVEL_TYPE, get_level_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_physics_configs(_package); i++)
-		{
-			_resman->load(PHYSICS_CONFIG_TYPE, get_physics_config_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_shaders(_package); i++)
-		{
-			_resman->load(SHADER_TYPE, get_shader_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_sprite_animations(_package); i++)
-		{
-			_resman->load(SPRITE_ANIMATION_TYPE, get_sprite_animation_id(_package, i));
-		}
-	}
+	void load();
 
 	/// Unloads all the resources in the package.
-	void unload()
-	{
-		using namespace package_resource;
-
-		for (uint32_t i = 0; i < num_sprite_animations(_package); i++)
-		{
-			_resman->unload(SPRITE_ANIMATION_TYPE, get_sprite_animation_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_shaders(_package); i++)
-		{
-			_resman->unload(SHADER_TYPE, get_shader_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_physics_configs(_package); i++)
-		{
-			_resman->unload(PHYSICS_CONFIG_TYPE, get_physics_config_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_levels(_package); i++)
-		{
-			_resman->unload(LEVEL_TYPE, get_level_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_fonts(_package); i++)
-		{
-			_resman->unload(FONT_TYPE, get_font_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_materials(_package); i++)
-		{
-			_resman->unload(MATERIAL_TYPE, get_material_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_physics(_package); i++)
-		{
-			_resman->unload(PHYSICS_TYPE, get_physics_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_sprites(_package); i++)
-		{
-			_resman->unload(SPRITE_TYPE, get_sprite_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_units(_package); i++)
-		{
-			_resman->unload(UNIT_TYPE, get_unit_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_meshes(_package); i++)
-		{
-			_resman->unload(MESH_TYPE, get_mesh_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_sounds(_package); i++)
-		{
-			_resman->unload(SOUND_TYPE, get_sound_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_scripts(_package); i++)
-		{
-			_resman->unload(SCRIPT_TYPE, get_script_id(_package, i));
-		}
-
-		for (uint32_t i = 0; i < num_textures(_package); i++)
-		{
-			_resman->unload(TEXTURE_TYPE, get_texture_id(_package, i));
-		}
-	}
+	void unload();
 
 	/// Waits until the package has been loaded.
-	void flush()
-	{
-		_resman->flush();
-	}
+	void flush();
 
 	/// Returns whether the package has been loaded.
-	bool has_loaded() const
-	{
-		using namespace package_resource;
-
-		for (uint32_t i = 0; i < num_textures(_package); i++)
-		{
-			if (!_resman->can_get(TEXTURE_TYPE, get_texture_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_scripts(_package); i++)
-		{
-			if (!_resman->can_get(SCRIPT_TYPE, get_script_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_sounds(_package); i++)
-		{
-			if (!_resman->can_get(SOUND_TYPE, get_sound_id(_package, i)))
-				return false;
-		}
+	bool has_loaded() const;
 
-		for (uint32_t i = 0; i < num_meshes(_package); i++)
-		{
-			if (!_resman->can_get(MESH_TYPE, get_mesh_id(_package, i)))
-				return false;
-		}
+public:
 
-		for (uint32_t i = 0; i < num_units(_package); i++)
-		{
-			if (!_resman->can_get(UNIT_TYPE, get_unit_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_sprites(_package); i++)
-		{
-			if (!_resman->can_get(SPRITE_TYPE, get_sprite_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_physics(_package); i++)
-		{
-			if (!_resman->can_get(PHYSICS_TYPE, get_physics_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_materials(_package); i++)
-		{
-			if (!_resman->can_get(MATERIAL_TYPE, get_material_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_fonts(_package); i++)
-		{
-			if (!_resman->can_get(FONT_TYPE, get_font_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_levels(_package); i++)
-		{
-			if (!_resman->can_get(LEVEL_TYPE, get_level_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_physics_configs(_package); i++)
-		{
-			if (!_resman->can_get(PHYSICS_CONFIG_TYPE, get_physics_config_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_shaders(_package); i++)
-		{
-			if (!_resman->can_get(SHADER_TYPE, get_shader_id(_package, i)))
-				return false;
-		}
-
-		for (uint32_t i = 0; i < num_sprite_animations(_package); i++)
-		{
-			if (!_resman->can_get(SPRITE_ANIMATION_TYPE, get_sprite_animation_id(_package, i)))
-				return false;
-		}
-
-		return true;
-	}
+	enum { MARKER = 0x9a1ac68c };
 
 private:
 
+	uint32_t _marker;
+
 	ResourceManager* _resman;
 	StringId64 _id;
 	const PackageResource* _package;