Do not use ResourceId externally

engine/device.cpp

@@ -102,10 +102,7 @@ void Device::init()
 	_boot_package->load();
 	_boot_package->flush();
 
-	ResourceId bootid;
-	bootid.type = LUA_TYPE;
-	bootid.name = _boot_script_id;
-	_lua_environment->execute((LuaResource*) _resource_manager->get(bootid));
+	_lua_environment->execute((LuaResource*)_resource_manager->get(LUA_TYPE, _boot_script_id));
 	_lua_environment->call_global("init", 0);
 }
 

engine/lua/lua_system.cpp

@@ -124,16 +124,8 @@ namespace lua_system
 	{
 		using namespace lua_resource;
 		LuaStack stack(L);
-		const char* filename = stack.get_string(1);
-		const ResourceId lua_res("lua", filename);
-		device()->resource_manager()->load(lua_res);
-		device()->resource_manager()->flush();
-
-		const LuaResource* lr = (LuaResource*) device()->resource_manager()->get(lua_res);
+		const LuaResource* lr = (LuaResource*)device()->resource_manager()->get("lua", stack.get_string(1));
 		luaL_loadbuffer(L, program(lr), size(lr), "");
-
-		device()->resource_manager()->unload(lua_res);
-
 		return 1;
 	}
 

engine/physics/actor.cpp

@@ -163,7 +163,7 @@ void Actor::create_objects()
 			}
 			case PhysicsShapeType::CONVEX_MESH:
 			{
-				MeshResource* resource = (MeshResource*) device()->resource_manager()->get(shape->resource);
+				MeshResource* resource = (MeshResource*) device()->resource_manager()->get(MESH_TYPE, shape->resource.name);
 
 				PxConvexMeshDesc convex_mesh_desc;
 				convex_mesh_desc.points.count		= resource->num_vertices();

engine/renderers/material.cpp

@@ -56,10 +56,7 @@ void Material::destroy() const
 
 void Material::bind() const
 {
-	ResourceId shader_id;
-	shader_id.type = SHADER_TYPE;
-	shader_id.name = shader(resource);
-	Shader* shader = (Shader*) device()->resource_manager()->get(shader_id);
+	Shader* shader = (Shader*) device()->resource_manager()->get(SHADER_TYPE, material_resource::shader(resource));
 	bgfx::setProgram(shader->program);
 
 	// Set samplers
@@ -72,10 +69,7 @@ void Material::bind() const
 		bgfx::TextureHandle texture;
 		sampler.idx = th->sampler_handle;
 
-		ResourceId texid;
-		texid.type = TEXTURE_TYPE;
-		texid.name = td->id;
-		TextureResource* teximg = (TextureResource*) device()->resource_manager()->get(texid);
+		TextureResource* teximg = (TextureResource*) device()->resource_manager()->get(TEXTURE_TYPE, td->id);
 		texture.idx = teximg->handle.idx;
 
 		bgfx::setTexture(i, sampler, texture);

engine/renderers/material_manager.cpp

@@ -58,11 +58,8 @@ MaterialManager::MaterialManager()
 
 MaterialId MaterialManager::create_material(StringId64 id)
 {
-	ResourceId res_id;
-	res_id.type = MATERIAL_TYPE;
-	res_id.name = id;
 	MaterialId new_id = id_table::create(_materials_ids);
-	_materials[new_id.index].create((MaterialResource*) device()->resource_manager()->get(res_id), *this);
+	_materials[new_id.index].create((MaterialResource*) device()->resource_manager()->get(MATERIAL_TYPE, id), *this);
 	return new_id;
 }
 

engine/renderers/shader.cpp

@@ -141,11 +141,7 @@ namespace shader_resource
 
 	void online(StringId64 id, ResourceManager& rm)
 	{
-		ResourceId res_id;
-		res_id.type = SHADER_TYPE;
-		res_id.name = id;
-
-		Shader* shader = (Shader*) rm.get(res_id);
+		Shader* shader = (Shader*) rm.get(SHADER_TYPE, id);
 		bgfx::ShaderHandle vs = bgfx::createShader(shader->vs);
 		bgfx::ShaderHandle fs = bgfx::createShader(shader->fs);
 		shader->program = bgfx::createProgram(vs, fs, true);
@@ -153,11 +149,7 @@ namespace shader_resource
 
 	void offline(StringId64 id, ResourceManager& rm)
 	{
-		ResourceId res_id;
-		res_id.type = SHADER_TYPE;
-		res_id.name = id;
-
-		Shader* shader = (Shader*) rm.get(res_id);
+		Shader* shader = (Shader*) rm.get(SHADER_TYPE, id);
 		bgfx::destroyProgram(shader->program);
 	}
 

engine/resource/material_resource.cpp

@@ -236,10 +236,7 @@ namespace material_resource
 
 	void online(StringId64 id, ResourceManager& rm)
 	{
-		ResourceId res_id;
-		res_id.type = MATERIAL_TYPE;
-		res_id.name = id;
-		MaterialResource* mr = (MaterialResource*) rm.get(res_id);
+		MaterialResource* mr = (MaterialResource*) rm.get(MATERIAL_TYPE, id);
 
 		char* base = (char*)mr + dynamic_data_offset(mr);
 
@@ -260,10 +257,7 @@ namespace material_resource
 
 	void offline(StringId64 id, ResourceManager& rm)
 	{
-		ResourceId res_id;
-		res_id.type = MATERIAL_TYPE;
-		res_id.name = id;
-		MaterialResource* mr = (MaterialResource*) rm.get(res_id);
+		MaterialResource* mr = (MaterialResource*) rm.get(MATERIAL_TYPE, id);
 
 		char* base = (char*) mr + dynamic_data_offset(mr);
 

engine/resource/package_resource.cpp

@@ -78,92 +78,92 @@ namespace package_resource
 		opts.write(offt);
 
 		opts.write(num_scripts);
-		offt += sizeof(ResourceId) * num_textures;
+		offt += sizeof(StringId64) * num_textures;
 		opts.write(offt);
 
 		opts.write(num_sounds);
-		offt += sizeof(ResourceId) * num_scripts;
+		offt += sizeof(StringId64) * num_scripts;
 		opts.write(offt);
 
 		opts.write(num_meshes);
-		offt += sizeof(ResourceId) * num_sounds;
+		offt += sizeof(StringId64) * num_sounds;
 		opts.write(offt);
 
 		opts.write(num_units);
-		offt += sizeof(ResourceId) * num_meshes;
+		offt += sizeof(StringId64) * num_meshes;
 		opts.write(offt);
 
 		opts.write(num_sprites);
-		offt += sizeof(ResourceId) * num_units;
+		offt += sizeof(StringId64) * num_units;
 		opts.write(offt);
 
 		opts.write(num_physics);
-		offt += sizeof(ResourceId) * num_sprites;
+		offt += sizeof(StringId64) * num_sprites;
 		opts.write(offt);
 
 		opts.write(num_materials);
-		offt += sizeof(ResourceId) * num_physics;
+		offt += sizeof(StringId64) * num_physics;
 		opts.write(offt);
 
 		opts.write(num_fonts);
-		offt += sizeof(ResourceId) * num_materials;
+		offt += sizeof(StringId64) * num_materials;
 		opts.write(offt);
 
 		opts.write(num_levels);
-		offt += sizeof(ResourceId) * num_fonts;
+		offt += sizeof(StringId64) * num_fonts;
 		opts.write(offt);
 
 		opts.write(num_phyconfs);
-		offt += sizeof(ResourceId) * num_levels;
+		offt += sizeof(StringId64) * num_levels;
 		opts.write(offt);
 
 		opts.write(num_shaders);
-		offt += sizeof(ResourceId) * num_phyconfs;
+		offt += sizeof(StringId64) * num_phyconfs;
 		opts.write(offt);
 
 		opts.write(num_sprite_animations);
-		offt += sizeof(ResourceId) * num_shaders;
+		offt += sizeof(StringId64) * num_shaders;
 		opts.write(offt);
 
 		// Write resource ids
 		for (uint32_t i = 0; i < num_textures; i++)
-			opts.write(texture[i].to_resource_id("texture"));
+			opts.write(texture[i].to_resource_id("texture").name);
 
 		for (uint32_t i = 0; i < num_scripts; i++)
-			opts.write(script[i].to_resource_id("lua"));
+			opts.write(script[i].to_resource_id("lua").name);
 
 		for (uint32_t i = 0; i < num_sounds; i++)
-			opts.write(sound[i].to_resource_id("sound"));
+			opts.write(sound[i].to_resource_id("sound").name);
 
 		for (uint32_t i = 0; i < num_meshes; i++)
-			opts.write(mesh[i].to_resource_id("mesh"));
+			opts.write(mesh[i].to_resource_id("mesh").name);
 
 		for (uint32_t i = 0; i < num_units; i++)
-			opts.write(unit[i].to_resource_id("unit"));
+			opts.write(unit[i].to_resource_id("unit").name);
 
 		for (uint32_t i = 0; i < num_sprites; i++)
-			opts.write(sprite[i].to_resource_id("sprite"));
+			opts.write(sprite[i].to_resource_id("sprite").name);
 
 		for (uint32_t i = 0; i < num_physics; i++)
-			opts.write(physics[i].to_resource_id("physics"));
+			opts.write(physics[i].to_resource_id("physics").name);
 
 		for (uint32_t i = 0; i < num_materials; i++)
-			opts.write(material[i].to_resource_id("material"));
+			opts.write(material[i].to_resource_id("material").name);
 
 		for (uint32_t i = 0; i < num_fonts; i++)
-			opts.write(font[i].to_resource_id("font"));
+			opts.write(font[i].to_resource_id("font").name);
 
 		for (uint32_t i = 0; i < num_levels; i++)
-			opts.write(level[i].to_resource_id("level"));
+			opts.write(level[i].to_resource_id("level").name);
 
 		for (uint32_t i = 0; i < num_phyconfs; i++)
-			opts.write(phyconf[i].to_resource_id("physics_config"));
+			opts.write(phyconf[i].to_resource_id("physics_config").name);
 
 		for (uint32_t i = 0; i < num_shaders; i++)
-			opts.write(shader[i].to_resource_id("shader"));
+			opts.write(shader[i].to_resource_id("shader").name);
 
 		for (uint32_t i = 0; i < num_sprite_animations; i++)
-			opts.write(sprite_animation[i].to_resource_id("sprite_animation"));
+			opts.write(sprite_animation[i].to_resource_id("sprite_animation").name);
 	}
 
 	void* load(Allocator& allocator, Bundle& bundle, ResourceId id)
@@ -257,107 +257,94 @@ namespace package_resource
 		return pr->num_sprite_animations;
 	}
 
-	ResourceId get_texture_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_texture_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_textures(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->textures_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->textures_offset);
 		return begin[i];
 	}
 
-	ResourceId get_script_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_script_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_scripts(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->scripts_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->scripts_offset);
 		return begin[i];
 	}
 
-	ResourceId get_sound_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_sound_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_sounds(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->sounds_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->sounds_offset);
 		return begin[i];
 	}
 
-	ResourceId get_mesh_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_mesh_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_meshes(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->meshes_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->meshes_offset);
 		return begin[i];
 	}
 
-	ResourceId get_unit_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_unit_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_units(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->units_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->units_offset);
 		return begin[i];
 	}
 
-	ResourceId get_sprite_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_sprite_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_sprites(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->sprites_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->sprites_offset);
 		return begin[i];
 	}
 
-	ResourceId get_physics_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_physics_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_physics(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->physics_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->physics_offset);
 		return begin[i];
 	}
 
-	ResourceId get_material_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_material_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_materials(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->materials_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->materials_offset);
 		return begin[i];
 	}
 
-	ResourceId get_font_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_font_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_fonts(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->fonts_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->fonts_offset);
 		return begin[i];
 	}
 
-	ResourceId get_level_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_level_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_levels(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->levels_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->levels_offset);
 		return begin[i];
 	}
 
-	ResourceId get_physics_config_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_physics_config_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_physics_configs(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->physics_configs_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->physics_configs_offset);
 		return begin[i];
 	}
 
-	ResourceId get_shader_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_shader_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_shaders(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->shaders_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->shaders_offset);
 		return begin[i];
 	}
 
-	ResourceId get_sprite_animation_id(const PackageResource* pr, uint32_t i)
+	StringId64 get_sprite_animation_id(const PackageResource* pr, uint32_t i)
 	{
 		CE_ASSERT(i < num_sprite_animations(pr), "Index out of bounds");
-
-		ResourceId* begin = (ResourceId*) ((char*)pr + pr->sprite_animations_offset);
+		StringId64* begin = (StringId64*) ((char*)pr + pr->sprite_animations_offset);
 		return begin[i];
 	}
 } // namespace package_resource

engine/resource/package_resource.h

@@ -87,18 +87,18 @@ namespace package_resource
 	uint32_t num_physics_configs(const PackageResource* pr);
 	uint32_t num_shaders(const PackageResource* pr);
 	uint32_t num_sprite_animations(const PackageResource* pr);
-	ResourceId get_texture_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_script_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_sound_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_mesh_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_unit_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_sprite_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_physics_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_material_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_font_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_level_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_physics_config_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_shader_id(const PackageResource* pr, uint32_t i);
-	ResourceId get_sprite_animation_id(const PackageResource* pr, uint32_t i);
+	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

engine/resource/resource_manager.cpp

@@ -52,6 +52,14 @@ ResourceManager::ResourceManager(Bundle& bundle)
 {
 }
 
+void ResourceManager::load(StringId64 type, StringId64 name)
+{
+	ResourceId id;
+	id.type = type;
+	id.name = name;
+	load(id);
+}
+
 void ResourceManager::load(ResourceId id)
 {
 	// Search for an already existent resource
@@ -68,7 +76,23 @@ void ResourceManager::load(ResourceId id)
 	entry->references++;
 }
 
-void ResourceManager::unload(ResourceId id, bool force)
+bool ResourceManager::can_get(StringId64 type, StringId64 name)
+{
+	ResourceId id;
+	id.type = type;
+	id.name = name;
+	return can_get(id);
+}
+
+void ResourceManager::unload(StringId64 type, StringId64 name)
+{
+	ResourceId id;
+	id.type = type;
+	id.name = name;
+	unload(id);
+}
+
+void ResourceManager::unload(ResourceId id)
 {
 	CE_ASSERT(find(id) != NULL, "Resource not loaded: ""%.16"PRIx64"-%.16"PRIx64, id.type, id.name);
 
@@ -76,7 +100,7 @@ void ResourceManager::unload(ResourceId id, bool force)
 	ResourceEntry* entry = find(id);
 	entry->references--;
 
-	if (entry->references == 0 || force)
+	if (entry->references == 0)
 	{
 		resource_on_offline(id.type, id.name, *this);
 		resource_on_unload(id.type, m_resource_heap, entry->resource);
@@ -105,6 +129,14 @@ const void* ResourceManager::get(const char* type, const char* name) const
 	return entry->resource;
 }
 
+const void* ResourceManager::get(StringId64 type, StringId64 name)
+{
+	ResourceId id;
+	id.type = type;
+	id.name = name;
+	return get(id);
+}
+
 const void* ResourceManager::get(ResourceId id) const
 {
 	CE_ASSERT(find(id) != NULL, "Resource not loaded: ""%.16"PRIx64"-%.16"PRIx64, id.type, id.name);

engine/resource/resource_manager.h

@@ -59,28 +59,24 @@ public:
 	/// The resources will be loaded from @a bundle.
 	ResourceManager(Bundle& bundle);
 
-	/// Loads the resource @a id.
+	/// Loads the resource @a type @a name.
 	/// You can check whether the resource is loaded with can_get().
-	void load(ResourceId id);
+	void load(StringId64 type, StringId64 name);
 
-	/// Unloads the resource @a id.
-	/// If @a force is true, the resource is unloaded even if its reference count
-	/// is greater than 1.
-	/// @warning
-	/// Use @a force option only if you know *exactly* what you are doing.
-	void unload(ResourceId id, bool force = false);
+	/// Unloads the resource @a type @a name.
+	void unload(StringId64 type, StringId64 name);
 
 	/// Returns whether the manager has the given resource. 
 	bool can_get(const char* type, const char* name);
 
 	/// Returns whether the manager has the resource @a id.
-	bool can_get(ResourceId id) const;
+	bool can_get(StringId64 type, StringId64 name);
 
 	/// Returns the resource data by @a type and @a name.
 	const void* get(const char* type, const char* name) const;
 
 	/// Returns the resource data by @a id.
-	const void* get(ResourceId id) const;
+	const void* get(StringId64 type, StringId64 name);
 
 	/// Returns the number of references to resource @a id;
 	uint32_t references(ResourceId id) const;
@@ -93,6 +89,11 @@ public:
 
 private:
 
+	void load(ResourceId id);
+	void unload(ResourceId id);
+	bool can_get(ResourceId id) const;
+	const void* get(ResourceId id) const;
+
 	ResourceEntry* find(ResourceId id) const;
 	void complete_request(ResourceId id, void* data);
 

engine/resource/resource_package.h

@@ -39,20 +39,19 @@ namespace crown
 struct ResourcePackage
 {
 	ResourcePackage(StringId64 id, ResourceManager& resman)
-		: m_resource_manager(&resman)
-		, m_package(NULL)
-		, m_has_loaded(false)
+		: _resman(&resman)
+		, _id(id)
+		, _package(NULL)
+		, _has_loaded(false)
 	{
-		m_id.type = PACKAGE_TYPE;
-		m_id.name = id;
-		resman.load(m_id);
+		resman.load(PACKAGE_TYPE, _id);
 		resman.flush();
-		m_package = (const PackageResource*) resman.get(m_id);
+		_package = (const PackageResource*) resman.get(PACKAGE_TYPE, _id);
 	}
 
 	~ResourcePackage()
 	{
-		m_resource_manager->unload(m_id);
+		_resman->unload(PACKAGE_TYPE, _id);
 	}
 
 	/// Loads all the resources in the package.
@@ -63,69 +62,69 @@ struct ResourcePackage
 	{
 		using namespace package_resource;
 
-		for (uint32_t i = 0; i < num_textures(m_package); i++)
+		for (uint32_t i = 0; i < num_textures(_package); i++)
 		{
-			m_resource_manager->load(get_texture_id(m_package, i));
+			_resman->load(TEXTURE_TYPE, get_texture_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_scripts(m_package); i++)
+		for (uint32_t i = 0; i < num_scripts(_package); i++)
 		{
-			m_resource_manager->load(get_script_id(m_package, i));
+			_resman->load(LUA_TYPE, get_script_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_sounds(m_package); i++)
+		for (uint32_t i = 0; i < num_sounds(_package); i++)
 		{
-			m_resource_manager->load(get_sound_id(m_package, i));
+			_resman->load(SOUND_TYPE, get_sound_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_meshes(m_package); i++)
+		for (uint32_t i = 0; i < num_meshes(_package); i++)
 		{
-			m_resource_manager->load(get_mesh_id(m_package, i));
+			_resman->load(MESH_TYPE, get_mesh_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_units(m_package); i++)
+		for (uint32_t i = 0; i < num_units(_package); i++)
 		{
-			m_resource_manager->load(get_unit_id(m_package, i));
+			_resman->load(UNIT_TYPE, get_unit_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_sprites(m_package); i++)
+		for (uint32_t i = 0; i < num_sprites(_package); i++)
 		{
-			m_resource_manager->load(get_sprite_id(m_package, i));
+			_resman->load(SPRITE_TYPE, get_sprite_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_physics(m_package); i++)
+		for (uint32_t i = 0; i < num_physics(_package); i++)
 		{
-			m_resource_manager->load(get_physics_id(m_package, i));
+			_resman->load(PHYSICS_TYPE, get_physics_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_materials(m_package); i++)
+		for (uint32_t i = 0; i < num_materials(_package); i++)
 		{
-			m_resource_manager->load(get_material_id(m_package, i));
+			_resman->load(MATERIAL_TYPE, get_material_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_fonts(m_package); i++)
+		for (uint32_t i = 0; i < num_fonts(_package); i++)
 		{
-			m_resource_manager->load(get_font_id(m_package, i));
+			_resman->load(FONT_TYPE, get_font_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_levels(m_package); i++)
+		for (uint32_t i = 0; i < num_levels(_package); i++)
 		{
-			m_resource_manager->load(get_level_id(m_package, i));
+			_resman->load(LEVEL_TYPE, get_level_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_physics_configs(m_package); i++)
+		for (uint32_t i = 0; i < num_physics_configs(_package); i++)
 		{
-			m_resource_manager->load(get_physics_config_id(m_package, i));
+			_resman->load(PHYSICS_CONFIG_TYPE, get_physics_config_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_shaders(m_package); i++)
+		for (uint32_t i = 0; i < num_shaders(_package); i++)
 		{
-			m_resource_manager->load(get_shader_id(m_package, i));
+			_resman->load(SHADER_TYPE, get_shader_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_sprite_animations(m_package); i++)
+		for (uint32_t i = 0; i < num_sprite_animations(_package); i++)
 		{
-			m_resource_manager->load(get_sprite_animation_id(m_package, i));
+			_resman->load(SPRITE_ANIMATION_TYPE, get_sprite_animation_id(_package, i));
 		}
 	}
 
@@ -134,91 +133,91 @@ struct ResourcePackage
 	{
 		using namespace package_resource;
 		
-		for (uint32_t i = 0; i < num_sprite_animations(m_package); i++)
+		for (uint32_t i = 0; i < num_sprite_animations(_package); i++)
 		{
-			m_resource_manager->unload(get_sprite_animation_id(m_package, i));
+			_resman->unload(SPRITE_ANIMATION_TYPE, get_sprite_animation_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_shaders(m_package); i++)
+		for (uint32_t i = 0; i < num_shaders(_package); i++)
 		{
-			m_resource_manager->unload(get_shader_id(m_package, i));
+			_resman->unload(SHADER_TYPE, get_shader_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_physics_configs(m_package); i++)
+		for (uint32_t i = 0; i < num_physics_configs(_package); i++)
 		{
-			m_resource_manager->unload(get_physics_config_id(m_package, i));
+			_resman->unload(PHYSICS_CONFIG_TYPE, get_physics_config_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_levels(m_package); i++)
+		for (uint32_t i = 0; i < num_levels(_package); i++)
 		{
-			m_resource_manager->unload(get_level_id(m_package, i));
+			_resman->unload(LEVEL_TYPE, get_level_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_fonts(m_package); i++)
+		for (uint32_t i = 0; i < num_fonts(_package); i++)
 		{
-			m_resource_manager->unload(get_font_id(m_package, i));
+			_resman->unload(FONT_TYPE, get_font_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_materials(m_package); i++)
+		for (uint32_t i = 0; i < num_materials(_package); i++)
 		{
-			m_resource_manager->unload(get_material_id(m_package, i));
+			_resman->unload(MATERIAL_TYPE, get_material_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_physics(m_package); i++)
+		for (uint32_t i = 0; i < num_physics(_package); i++)
 		{
-			m_resource_manager->unload(get_physics_id(m_package, i));
+			_resman->unload(PHYSICS_TYPE, get_physics_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_sprites(m_package); i++)
+		for (uint32_t i = 0; i < num_sprites(_package); i++)
 		{
-			m_resource_manager->unload(get_sprite_id(m_package, i));
+			_resman->unload(SPRITE_TYPE, get_sprite_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_units(m_package); i++)
+		for (uint32_t i = 0; i < num_units(_package); i++)
 		{
-			m_resource_manager->unload(get_unit_id(m_package, i));
+			_resman->unload(UNIT_TYPE, get_unit_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_meshes(m_package); i++)
+		for (uint32_t i = 0; i < num_meshes(_package); i++)
 		{
-			m_resource_manager->unload(get_mesh_id(m_package, i));
+			_resman->unload(MESH_TYPE, get_mesh_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_sounds(m_package); i++)
+		for (uint32_t i = 0; i < num_sounds(_package); i++)
 		{
-			m_resource_manager->unload(get_sound_id(m_package, i));
+			_resman->unload(SOUND_TYPE, get_sound_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_scripts(m_package); i++)
+		for (uint32_t i = 0; i < num_scripts(_package); i++)
 		{
-			m_resource_manager->unload(get_script_id(m_package, i));
+			_resman->unload(LUA_TYPE, get_script_id(_package, i));
 		}
 
-		for (uint32_t i = 0; i < num_textures(m_package); i++)
+		for (uint32_t i = 0; i < num_textures(_package); i++)
 		{
-			m_resource_manager->unload(get_texture_id(m_package, i));
+			_resman->unload(TEXTURE_TYPE, get_texture_id(_package, i));
 		}
 	}
 
 	/// Waits until the package has been loaded.
 	void flush()
 	{
-		m_resource_manager->flush();
-		m_has_loaded = true;
+		_resman->flush();
+		_has_loaded = true;
 	}
 
 	/// Returns whether the package has been loaded.
 	bool has_loaded() const
 	{
-		return m_has_loaded;
+		return _has_loaded;
 	}
 
 private:
 
-	ResourceManager* m_resource_manager;
-	ResourceId m_id;
-	const PackageResource* m_package;
-	bool m_has_loaded;
+	ResourceManager* _resman;
+	StringId64 _id;
+	const PackageResource* _package;
+	bool _has_loaded;
 };
 
 } // namespace crown

engine/resource/sprite_resource.cpp

@@ -165,11 +165,7 @@ namespace sprite_resource
 
 	void online(StringId64 id, ResourceManager& rm)
 	{
-		ResourceId res_id;
-		res_id.type = SPRITE_TYPE;
-		res_id.name = id;
-
-		SpriteResource* so = (SpriteResource*) rm.get(res_id);
+		SpriteResource* so = (SpriteResource*) rm.get(SPRITE_TYPE, id);
 
 		bgfx::VertexDecl decl;
 		decl.begin()
@@ -183,11 +179,7 @@ namespace sprite_resource
 
 	void offline(StringId64 id, ResourceManager& rm)
 	{
-		ResourceId res_id;
-		res_id.type = SPRITE_TYPE;
-		res_id.name = id;
-
-		SpriteResource* so = (SpriteResource*) rm.get(res_id);
+		SpriteResource* so = (SpriteResource*) rm.get(SPRITE_TYPE, id);
 
 		bgfx::destroyVertexBuffer(so->vb);
 		bgfx::destroyIndexBuffer(so->ib);

engine/resource/texture_resource.cpp

@@ -640,21 +640,13 @@ namespace texture_resource
 
 	void online(StringId64 id, ResourceManager& rm)
 	{
-		ResourceId res_id;
-		res_id.type = TEXTURE_TYPE;
-		res_id.name = id;
-
-		TextureResource* teximg = (TextureResource*) rm.get(res_id);
+		TextureResource* teximg = (TextureResource*) rm.get(TEXTURE_TYPE, id);
 		teximg->handle = bgfx::createTexture(teximg->mem);
 	}
 
 	void offline(StringId64 id, ResourceManager& rm)
 	{
-		ResourceId res_id;
-		res_id.type = TEXTURE_TYPE;
-		res_id.name = id;
-
-		TextureResource* teximg = (TextureResource*) rm.get(res_id);
+		TextureResource* teximg = (TextureResource*) rm.get(TEXTURE_TYPE, id);
 		bgfx::destroyTexture(teximg->handle);
 	}
 	

engine/resource/unit_resource.cpp

@@ -231,12 +231,12 @@ namespace unit_resource
 			if (res_type == "mesh")
 			{
 				rn.type = UnitRenderable::MESH;
-				rn.resource = renderable.key("resource").to_resource_id("mesh");
+				rn.resource = renderable.key("resource").to_resource_id("mesh").name;
 			}
 			else if (res_type == "sprite")
 			{
 				rn.type = UnitRenderable::SPRITE;
-				rn.resource = renderable.key("resource").to_resource_id("sprite");
+				rn.resource = renderable.key("resource").to_resource_id("sprite").name;
 			}
 			else
 			{
@@ -374,7 +374,7 @@ namespace unit_resource
 
 		UnitResource ur;
 		ur.version = VERSION;
-		ur.physics_resource = m_physics_resource;
+		ur.physics_resource = m_physics_resource.name;
 		ur.sprite_animation = sprite_anim.name;
 		ur.num_renderables = array::size(m_renderables);
 		ur.num_materials = array::size(m_materials);
@@ -498,15 +498,12 @@ namespace unit_resource
 		allocator.deallocate(resource);
 	}
 
-	ResourceId sprite_animation(const UnitResource* ur)
+	StringId64 sprite_animation(const UnitResource* ur)
 	{
-		ResourceId id;
-		id.type = SPRITE_ANIMATION_TYPE;
-		id.name = ur->sprite_animation;
-		return id;
+		return ur->sprite_animation;
 	}
 
-	ResourceId physics_resource(const UnitResource* ur)
+	StringId64 physics_resource(const UnitResource* ur)
 	{
 		return ur->physics_resource;
 	}

engine/resource/unit_resource.h

@@ -43,7 +43,7 @@ struct UnitResource
 {
 	uint32_t version;
 	uint32_t _pad;
-	ResourceId physics_resource;
+	StringId64 physics_resource;
 	StringId64 sprite_animation;
 	uint32_t num_renderables;
 	uint32_t renderables_offset;
@@ -64,7 +64,7 @@ struct UnitRenderable
 	enum Enum { MESH, SPRITE };
 	uint32_t type;
 	uint32_t _pad;
-	ResourceId resource;
+	StringId64 resource;
 	StringId32 name;
 	int32_t node;
 	bool visible;
@@ -120,8 +120,8 @@ namespace unit_resource
 	void offline(StringId64 /*id*/, ResourceManager& /*rm*/);
 	void unload(Allocator& allocator, void* resource);
 
-	ResourceId sprite_animation(const UnitResource* ur);
-	ResourceId physics_resource(const UnitResource* ur);
+	StringId64 sprite_animation(const UnitResource* ur);
+	StringId64 physics_resource(const UnitResource* ur);
 	uint32_t num_renderables(const UnitResource* ur);
 	const UnitRenderable* get_renderable(const UnitResource* ur, uint32_t i);
 	uint32_t num_materials(const UnitResource* ur);

engine/world/unit.cpp

@@ -43,11 +43,11 @@ namespace crown
 
 using namespace unit_resource;
 
-Unit::Unit(World& w, UnitId unit_id, const ResourceId id, const UnitResource* ur, const Matrix4x4& pose)
+Unit::Unit(World& w, UnitId unit_id, StringId64 resid, const UnitResource* ur, const Matrix4x4& pose)
 	: m_world(w)
 	, m_scene_graph(*w.scene_graph_manager()->create_scene_graph())
 	, m_sprite_animation(NULL)
-	, m_resource_id(id)
+	, m_resource_id(resid)
 	, m_resource(ur)
 	, m_id(unit_id)
 	, m_num_cameras(0)
@@ -96,10 +96,10 @@ void Unit::create_objects(const Matrix4x4& pose)
 	m_values = (char*) default_allocator().allocate(values_size(m_resource));
 	memcpy(m_values, values(m_resource), values_size(m_resource));
 
-	ResourceId anim_id = sprite_animation(m_resource);
-	if (anim_id.name != 0)
+	StringId64 anim_id = sprite_animation(m_resource);
+	if (anim_id != 0)
 	{
-		m_sprite_animation = m_world.sprite_animation_player()->create_sprite_animation((SpriteAnimationResource*) device()->resource_manager()->get(anim_id));
+		m_sprite_animation = m_world.sprite_animation_player()->create_sprite_animation((SpriteAnimationResource*) device()->resource_manager()->get(SPRITE_ANIMATION_TYPE, anim_id));
 	}
 }
 
@@ -177,13 +177,13 @@ void Unit::create_renderable_objects()
 
 		if (ur->type == UnitRenderable::MESH)
 		{
-			MeshResource* mr = (MeshResource*) device()->resource_manager()->get(ur->resource);
+			MeshResource* mr = (MeshResource*) device()->resource_manager()->get(MESH_TYPE, ur->resource);
 			MeshId mesh = m_world.render_world()->create_mesh(mr, m_scene_graph, ur->node);
 			add_mesh(ur->name, mesh);
 		}
 		else if (ur->type == UnitRenderable::SPRITE)
 		{
-			SpriteResource* sr = (SpriteResource*) device()->resource_manager()->get(ur->resource);
+			SpriteResource* sr = (SpriteResource*) device()->resource_manager()->get(SPRITE_TYPE, ur->resource);
 			SpriteId sprite = m_world.render_world()->create_sprite(sr, m_scene_graph, ur->node);
 			add_sprite(ur->name, sprite);
 		}
@@ -204,9 +204,9 @@ void Unit::create_physics_objects()
 {
 	using namespace unit_resource;
 	using namespace physics_resource;
-	if (unit_resource::physics_resource(m_resource).type != 0)
+	if (unit_resource::physics_resource(m_resource) != 0)
 	{
-		const PhysicsResource* pr = (PhysicsResource*) device()->resource_manager()->get(unit_resource::physics_resource(m_resource));
+		const PhysicsResource* pr = (PhysicsResource*) device()->resource_manager()->get(PHYSICS_TYPE, unit_resource::physics_resource(m_resource));
 
 		// Create controller if any
 		if (has_controller(pr))
@@ -526,7 +526,7 @@ Material* Unit::material(uint32_t i)
 
 bool Unit::is_a(const char* name)
 {
-	return m_resource_id == ResourceId("unit", name);
+	return m_resource_id == ResourceId("unit", name).name;
 }
 
 void Unit::play_sprite_animation(const char* name, bool loop)

engine/world/unit.h

@@ -77,7 +77,7 @@ struct UnitResource;
 /// @ingroup World
 struct Unit
 {
-	Unit(World& w, UnitId unit_id, const ResourceId id, const UnitResource* ur, const Matrix4x4& pose);
+	Unit(World& w, UnitId unit_id, StringId64 resid, const UnitResource* ur, const Matrix4x4& pose);
 	~Unit();
 
 	void set_id(const UnitId id);
@@ -192,7 +192,7 @@ public:
 	World& m_world;
 	SceneGraph& m_scene_graph;
 	SpriteAnimation* m_sprite_animation;
-	const ResourceId m_resource_id;
+	const StringId64 m_resource_id;
 	const UnitResource*	m_resource;
 	UnitId m_id;
 

engine/world/world.cpp

@@ -72,29 +72,16 @@ void World::set_id(WorldId id)
 UnitId World::spawn_unit(const char* name, const Vector3& pos, const Quaternion& rot)
 {
 	const ResourceId id(UNIT_EXTENSION, name);
-	return spawn_unit(id, pos, rot);
-}
-
-UnitId World::spawn_unit(ResourceId id, const Vector3& pos, const Quaternion& rot)
-{
-	UnitResource* ur = (UnitResource*) device()->resource_manager()->get(id);
-	return spawn_unit(id, ur, pos, rot);
+	return spawn_unit(id.name, pos, rot);
 }
 
 UnitId World::spawn_unit(StringId64 name, const Vector3& pos, const Quaternion& rot)
 {
-	ResourceId id;
-	id.type = UNIT_TYPE;
-	id.name = name;
-	UnitResource* ur = (UnitResource*) device()->resource_manager()->get(id);
-	return spawn_unit(id, ur, pos, rot);
-}
+	UnitResource* ur = (UnitResource*)device()->resource_manager()->get(UNIT_TYPE, name);
 
-UnitId World::spawn_unit(const ResourceId id, UnitResource* ur, const Vector3& pos, const Quaternion& rot)
-{
 	Unit* u = (Unit*) m_unit_pool.allocate(sizeof(Unit), CE_ALIGNOF(Unit));
 	const UnitId unit_id = id_array::create(m_units, u);
-	new (u) Unit(*this, unit_id, id, ur, Matrix4x4(rot, pos));
+	new (u) Unit(*this, unit_id, name, ur, Matrix4x4(rot, pos));
 
 	post_unit_spawned_event(unit_id);
 	return unit_id;
@@ -201,25 +188,12 @@ void World::destroy_camera(CameraId id)
 SoundInstanceId World::play_sound(const char* name, const bool loop, const float volume, const Vector3& pos, const float range)
 {
 	ResourceId id(SOUND_EXTENSION, name);
-	return play_sound(id, loop, volume, pos, range);
+	return play_sound(id.name, loop, volume, pos, range);
 }
 
 SoundInstanceId World::play_sound(StringId64 name, const bool loop, const float volume, const Vector3& pos, const float range)
 {
-	ResourceId id;
-	id.type = SOUND_TYPE;
-	id.name = name;
-	return play_sound(id, loop, volume, pos, range);
-}
-
-SoundInstanceId World::play_sound(ResourceId id, const bool loop, const float volume, const Vector3& pos, const float range)
-{
-	SoundResource* sr = (SoundResource*) device()->resource_manager()->get(id);
-	return play_sound(sr, loop, volume, pos, range);
-}
-
-SoundInstanceId World::play_sound(SoundResource* sr, const bool loop, const float volume, const Vector3& pos, const float range)
-{
+	SoundResource* sr = (SoundResource*)device()->resource_manager()->get(SOUND_TYPE, name);
 	return m_sound_world->play(sr, loop, volume, pos);
 }
 

engine/world/world.h

@@ -65,8 +65,6 @@ public:
 	/// Spawns a new instance of the unit @a name at the given @a position and @a rotation.
 	UnitId spawn_unit(const char* name, const Vector3& position = vector3::ZERO, const Quaternion& rotation = quaternion::IDENTITY);
 	UnitId spawn_unit(StringId64 name, const Vector3& pos, const Quaternion& rot);
-	UnitId spawn_unit(ResourceId id, const Vector3& pos, const Quaternion& rot);
-	UnitId spawn_unit(const ResourceId id, UnitResource* ur, const Vector3& pos, const Quaternion& rot);
 
 	/// Destroys the unit with the given @a id.
 	void destroy_unit(UnitId id);
@@ -114,8 +112,6 @@ public:
 	/// @a volume and @a range. @a loop controls whether the sound must loop or not.
 	SoundInstanceId play_sound(const char* name, bool loop = false, float volume = 1.0f, const Vector3& position = vector3::ZERO, float range = 50.0f);
 	SoundInstanceId play_sound(StringId64 name, const bool loop, const float volume, const Vector3& pos, const float range);
-	SoundInstanceId play_sound(ResourceId id, const bool loop, const float volume, const Vector3& pos, const float range);
-	SoundInstanceId play_sound(SoundResource* sr, const bool loop, const float volume, const Vector3& pos, const float range);
 
 	/// Stops the sound with the given @a id.
 	void stop_sound(SoundInstanceId id);