C++ AssetManager::get_texture方法代码示例

Terrain::Terrain(AssetManager &assetmanager,
                 const std::vector<gamedata::terrain_type> &terrain_meta,
                 const std::vector<gamedata::blending_mode> &blending_meta,
                 bool is_infinite)
	:
	infinite{is_infinite} {

	// TODO:
	//this->limit_positive =
	//this->limit_negative =

	// maps chunk position to chunks
	this->chunks = std::unordered_map<coord::chunk, TerrainChunk *, coord_chunk_hash>{};

	// activate blending
	this->blending_enabled = true;

	this->terrain_id_count         = terrain_meta.size();
	this->blendmode_count          = blending_meta.size();
	this->textures                 = new Texture*[this->terrain_id_count];
	this->blending_masks           = new Texture*[this->blendmode_count];
	this->terrain_id_priority_map  = new int[this->terrain_id_count];
	this->terrain_id_blendmode_map = new int[this->terrain_id_count];
	this->influences_buf           = new struct influence[this->terrain_id_count];


	log::dbg("terrain prefs: %lu tiletypes, %lu blendmodes", this->terrain_id_count, this->blendmode_count);

	// create tile textures (snow, ice, grass, whatever)
	for (size_t i = 0; i < this->terrain_id_count; i++) {
		auto line = &terrain_meta[i];
		terrain_t terrain_id = line->terrain_id;
		this->validate_terrain(terrain_id);

		// TODO: terrain double-define check?
		this->terrain_id_priority_map[terrain_id]  = line->blend_priority;
		this->terrain_id_blendmode_map[terrain_id] = line->blend_mode;

		// TODO: remove hardcoding and rely on nyan data
		char *terraintex_filename = util::format("converted/Data/terrain.drs/%d.slp.png", line->slp_id);
		std::string terraintex_filename_str{terraintex_filename};
		delete[] terraintex_filename;

		auto new_texture = assetmanager.get_texture(terraintex_filename_str);

		this->textures[terrain_id] = new_texture;
	}

	// create blending masks (see doc/media/blendomatic)
	for (size_t i = 0; i < this->blendmode_count; i++) {
		auto line = &blending_meta[i];

		char *mask_filename = util::format("converted/blendomatic.dat/mode%02d.png", line->blend_mode);
		std::string mask_filename_str{mask_filename};
		delete[] mask_filename;

		this->blending_masks[i] = assetmanager.get_texture(mask_filename_str);
	}

}

void GameSpec::load_terrain(AssetManager &am) {

	// Terrain data files
	util::Dir *data_dir = am.get_data_dir();
	util::Dir asset_dir = data_dir->append("converted");
	std::vector<gamedata::string_resource> string_resources;
	util::read_csv_file(asset_dir.join("string_resources.docx"), string_resources);
	std::vector<gamedata::terrain_type> terrain_meta;
	util::read_csv_file(asset_dir.join("gamedata/gamedata-empiresdat/0000-terrains.docx"), terrain_meta);
	std::vector<gamedata::blending_mode> blending_meta;
	util::read_csv_file(asset_dir.join("blending_modes.docx"), blending_meta);

	// remove any disabled textures
	terrain_meta.erase(
		std::remove_if(terrain_meta.begin(), terrain_meta.end(),
			[](const gamedata::terrain_type &t) { return !t.enabled; }),
		terrain_meta.end());

	// result attributes
	terrain_data.terrain_id_count         = terrain_meta.size();
	terrain_data.blendmode_count          = blending_meta.size();
	terrain_data.textures.reserve(terrain_data.terrain_id_count);
	terrain_data.blending_masks.reserve(terrain_data.blendmode_count);
	terrain_data.terrain_id_priority_map  = std::make_unique<int[]>(terrain_data.terrain_id_count);
	terrain_data.terrain_id_blendmode_map = std::make_unique<int[]>(terrain_data.terrain_id_count);
	terrain_data.influences_buf           = std::make_unique<struct influence[]>(terrain_data.terrain_id_count);


	log::log(MSG(dbg) << "Terrain prefs: " <<
		"tiletypes=" << terrain_data.terrain_id_count << ", "
		"blendmodes=" << terrain_data.blendmode_count);

	// create tile textures (snow, ice, grass, whatever)
	for (size_t i = 0; i < terrain_data.terrain_id_count; i++) {
		auto line = &terrain_meta[i];
		terrain_t terrain_id = i;

		// TODO: validate terrain_id < terrain_id_count

		// TODO: terrain double-define check?
		terrain_data.terrain_id_priority_map[terrain_id]  = line->blend_priority;
		terrain_data.terrain_id_blendmode_map[terrain_id] = line->blend_mode;

		// TODO: remove hardcoding and rely on nyan data
		auto terraintex_filename = util::sformat("%s/%d.slp.png", this->terrain_path.c_str(), line->slp_id);
		auto new_texture = am.get_texture(terraintex_filename);

		terrain_data.textures[terrain_id] = new_texture;
	}

	// create blending masks (see doc/media/blendomatic)
	for (size_t i = 0; i < terrain_data.blendmode_count; i++) {
		auto line = &blending_meta[i];

		std::string mask_filename = util::sformat("%s/mode%02d.png", this->blend_path.c_str(), line->blend_mode);
		terrain_data.blending_masks[i] = am.get_texture(mask_filename);
	}
}