C++ CTexture::getName方法代码示例

/* CTexture::loadPatchImage
 * Loads the image for the patch at [pindex] into [image]. Can deal
 * with textures-as-patches
 *******************************************************************/
bool CTexture::loadPatchImage(unsigned pindex, SImage& image, Archive* parent, Palette8bit* pal)
{
	// Check patch index
	if (pindex >= patches.size())
		return false;

	CTPatch* patch = patches[pindex];

	// If the texture is extended, search for textures-as-patches first
	// (as long as the patch name is different from this texture's name)
	if (extended && !(S_CMPNOCASE(patch->getName(), name)))
	{
		// Search the texture list we're in first
		if (in_list)
		{
			for (unsigned a = 0; a < in_list->nTextures(); a++)
			{
				CTexture* tex = in_list->getTexture(a);

				// Don't look past this texture in the list
				if (tex->getName() == name)
					break;

				// Check for name match
				if (S_CMPNOCASE(tex->getName(), patch->getName()))
				{
					// Load texture to image
					return tex->toImage(image, parent, pal);
				}
			}
		}

		// Otherwise, try the resource manager
		// TODO: Something has to be ignored here. The entire archive or just the current list?
		CTexture* tex = theResourceManager->getTexture(patch->getName(), parent);
		if (tex)
			return tex->toImage(image, parent, pal);
	}

	// Get patch entry
	ArchiveEntry* entry = patch->getPatchEntry(parent);

	// Load entry to image if valid
	if (entry)
		return Misc::loadImageFromEntry(&image, entry);
	else
		return false;
}

/* TextureXPanel::removeTexture
 * Removes any selected textures
 *******************************************************************/
void TextureXPanel::removeTexture()
{
	// Get selected textures
	vector<long> selection = list_textures->getSelection();

	// Begin recording undo level
	undo_manager->beginRecord("Remove Texture(s)");

	// Go through selection backwards
	for (int a = selection.size() - 1; a >= 0; a--)
	{
		// Remove texture from patch table entries
		CTexture* tex = texturex.getTexture(selection[a]);
		for (unsigned p = 0; p < tex->nPatches(); p++)
			tx_editor->patchTable().patch(tex->getPatch(p)->getName()).removeTextureUsage(tex->getName());

		// Record undo step
		undo_manager->recordUndoStep(new TextureCreateDeleteUS(this, tex, false));

		// Remove texture from list
		texturex.removeTexture(selection[a]);
	}

	// End recording undo level
	undo_manager->endRecord(true);

	// Clear selection & refresh
	list_textures->clearSelection();
	list_textures->updateList();
	texture_editor->clearTexture();

	// Update variables
	modified = true;
}

	TextureModificationUS(TextureXPanel* tx_panel, CTexture* texture)
		: tx_panel(tx_panel)
	{
		tex_copy = new CTexture();
		tex_copy->copyTexture(texture);
		tex_copy->setState(texture->getState());
		index = tx_panel->txList().textureIndex(tex_copy->getName());
	}

/* TextureXPanel::openTEXTUREX
 * Loads a TEXTUREx or TEXTURES format texture list into the editor
 *******************************************************************/
bool TextureXPanel::openTEXTUREX(ArchiveEntry* entry)
{
	// Open texture list (check format)
	if (entry->getType()->getFormat() == "texturex")
	{
		// TEXTURE1/2 format
		if (!texturex.readTEXTUREXData(entry, tx_editor->patchTable()))
			return false;

		// Create default texture editor
		texture_editor = new TextureEditorPanel(this, tx_editor);

		// Update patch table usage info
		for (size_t a = 0; a < texturex.nTextures(); a++)
		{
			CTexture* tex = texturex.getTexture(a);

			// Go through texture's patches
			for (size_t p = 0; p < tex->nPatches(); p++)
				tx_editor->patchTable().patch(tex->getPatch(p)->getName()).used_in.push_back(tex->getName());
		}
	}
	else
	{
		// TEXTURES format
		if (!texturex.readTEXTURESData(entry))
			return false;

		// Create extended texture editor
		texture_editor = new ZTextureEditorPanel(this, tx_editor);

		// Add 'type' column
		list_textures->InsertColumn(2, "Type");
	}

	tx_entry = entry;

	// Add texture editor area
	GetSizer()->Add(texture_editor, 1, wxEXPAND|wxALL, 4);
	texture_editor->setupLayout();

	// Update format label
	label_tx_format->SetLabel("Format: " + texturex.getTextureXFormatString());

	// Update texture list
	list_textures->updateList();

	return true;
}

/* TextureXListView::getItemText
 * Returns the string for [item] at [column]
 *******************************************************************/
string TextureXListView::getItemText(long item, long column, long index) const
{
	// Check texture list exists
	if (!texturex)
		return "INVALID INDEX";

	// Check index is ok
	if (index < 0 || (unsigned)index > texturex->nTextures())
		return "INVALID INDEX";

	// Get associated texture
	CTexture* tex = texturex->getTexture(index);

	if (column == 0)						// Name column
		return tex->getName();
	else if (column == 1)					// Size column
		return S_FMT("%dx%d", tex->getWidth(), tex->getHeight());
	else if (column == 2)					// Type column
		return tex->getType();
	else
		return "INVALID COLUMN";
}

/* TextureXList::writeTEXTUREXData
 * Writes the texture list in TEXTUREX format to [texturex], using
 * [patch_table] for patch information. Returns true on success,
 * false otherwise
 *******************************************************************/
bool TextureXList::writeTEXTUREXData(ArchiveEntry* texturex, PatchTable& patch_table) {
	// Check entry was given
	if (!texturex)
		return false;

	if (texturex->isLocked())
		return false;

	wxLogMessage("Writing " + getTextureXFormatString() + " format TEXTUREx entry");

	/* Total size of a TEXTUREx lump, in bytes:
		Header: 4 + (4 * numtextures)
		Textures:
			22 * numtextures (normal format)
			14 * numtextures (nameless format)
			18 * numtextures (Strife 1.1 format)
		Patches:
			10 * sum of patchcounts (normal and nameless formats)
			 6 * sum of patchcounts (Strife 1.1 format)
	*/
	size_t numpatchrefs = 0;
	size_t numtextures = textures.size();
	for (size_t i = 0; i < numtextures; ++i) {
		numpatchrefs += textures[i]->nPatches();
	}
	wxLogMessage("%i patch references in %i textures", numpatchrefs, numtextures);

	size_t datasize = 0;
	size_t headersize = 4 + (4 * numtextures);
	switch (txformat) {
		case TXF_NORMAL:	datasize = 4 + (26 * numtextures) + (10 * numpatchrefs); break;
		case TXF_NAMELESS:	datasize = 4 + (18 * numtextures) + (10 * numpatchrefs); break;
		case TXF_STRIFE11:	datasize = 4 + (22 * numtextures) + ( 6 * numpatchrefs); break;
		// Some compilers insist on having default cases.
		default: return false;
	}

	MemChunk txdata(datasize);
	int32_t* offsets = new int32_t[numtextures];
	int32_t foo = wxINT32_SWAP_ON_BE((signed) numtextures);

	// Write header
	txdata.seek(0, SEEK_SET);
	SAFEFUNC(txdata.write(&foo, 4));

	// Go to beginning of texture definitions
	SAFEFUNC(txdata.seek(4 + (numtextures*4), SEEK_SET));

	// Write texture entries
	for (size_t i = 0; i < numtextures; ++i) {
		// Get texture to write
		CTexture* tex = textures[i];

		// Set offset
		offsets[i] = (signed)txdata.currentPos();

		// Write texture entry
		switch (txformat) {
			case TXF_NORMAL:
			{
				// Create 'normal' doom format texture definition
				ftdef_t txdef;
				memset(txdef.name, 0, 8); // Set texture name to all 0's (to ensure compatibility with XWE)
				strncpy(txdef.name, CHR(tex->getName().Upper()), tex->getName().Len());
				txdef.flags			= 0;
				txdef.scale[0]		= (tex->getScaleX()*8);
				txdef.scale[1]		= (tex->getScaleY()*8);
				txdef.width			= tex->getWidth();
				txdef.height		= tex->getHeight();
				txdef.columndir[0]	= 0;
				txdef.columndir[1]	= 0;
				txdef.patchcount	= tex->nPatches();

				// Check for WorldPanning flag
				if (tex->world_panning)
					txdef.flags |= TX_WORLDPANNING;

				// Write texture definition
				SAFEFUNC(txdata.write(&txdef, 22));

				break;
			}
			case TXF_NAMELESS:
			{
				// Create nameless texture definition
				nltdef_t txdef;
				txdef.flags			= 0;
				txdef.scale[0]		= (tex->getScaleX()*8);
				txdef.scale[1]		= (tex->getScaleY()*8);
				txdef.width			= tex->getWidth();
				txdef.height		= tex->getHeight();
				txdef.columndir[0]	= 0;
				txdef.columndir[1]	= 0;
				txdef.patchcount	= tex->nPatches();

//.........这里部分代码省略.........

/* MapTextureManager::buildTexInfoList
 * (Re)builds lists with information about all currently available
 * resource textures and flats
 *******************************************************************/
void MapTextureManager::buildTexInfoList()
{
	// Clear
	tex_info.clear();
	flat_info.clear();

	// --- Textures ---

	// Composite textures
	vector<TextureResource::tex_res_t> textures;
	theResourceManager->getAllTextures(textures, NULL);
	for (unsigned a = 0; a < textures.size(); a++)
	{
		CTexture * tex = textures[a].tex;
		Archive* parent = textures[a].parent;
		if (tex->isExtended())
		{
			if (S_CMPNOCASE(tex->getType(), "texture") || S_CMPNOCASE(tex->getType(), "walltexture"))
				tex_info.push_back(map_texinfo_t(tex->getName(), TC_TEXTURES, parent));
			else if (S_CMPNOCASE(tex->getType(), "define"))
				tex_info.push_back(map_texinfo_t(tex->getName(), TC_HIRES, parent));
			else if (S_CMPNOCASE(tex->getType(), "flat"))
				flat_info.push_back(map_texinfo_t(tex->getName(), TC_TEXTURES, parent));
			// Ignore graphics, patches and sprites
		}
		else
			tex_info.push_back(map_texinfo_t(tex->getName(), TC_TEXTUREX, parent, "", tex->getIndex() + 1));
	}

	// Texture namespace patches (TX_)
	if (theGameConfiguration->txTextures())
	{
		vector<ArchiveEntry*> patches;
		theResourceManager->getAllPatchEntries(patches, NULL);
		for (unsigned a = 0; a < patches.size(); a++)
		{
			if (patches[a]->isInNamespace("textures") || patches[a]->isInNamespace("hires"))
			{
				// Determine texture path if it's in a pk3
				string path = patches[a]->getPath();
				if (path.StartsWith("/textures/"))
					path.Remove(0, 9);
				else if (path.StartsWith("/hires/"))
					path.Remove(0, 6);
				else
					path = "";

				tex_info.push_back(map_texinfo_t(patches[a]->getName(true), TC_TX, patches[a]->getParent(), path));
			}
		}
	}

	// Flats
	vector<ArchiveEntry*> flats;
	theResourceManager->getAllFlatEntries(flats, NULL);
	for (unsigned a = 0; a < flats.size(); a++)
	{
		ArchiveEntry* entry = flats[a];

		// Determine flat path if it's in a pk3
		string path = entry->getPath();
		if (path.StartsWith("/flats/") || path.StartsWith("/hires/"))
			path.Remove(0, 6);
		else
			path = "";

		flat_info.push_back(map_texinfo_t(entry->getName(true), TC_NONE, flats[a]->getParent(), path));
	}
}

CFont::CFont(CXMLTreeNode& fontNode, CGUI* gui)
    : CNamed(fontNode)
    , m_glyphs( MAX_GLYPHS_BATCH )
    , m_gui(gui)
    , m_textAlign(Rectf::Alignment::TOP_LEFT)
{
    auto mm = CEngine::GetSingleton().getMaterialManager();
    auto tm = CEngine::GetSingleton().getTextureManager();

    std::string fontFile = fontNode.GetPszProperty("path", "", false);
    std::string fontName = fontNode.GetPszProperty("name", "", false);
    DEBUG_ASSERT(fontFile.size() != 0 && fontName.size() != 0);
    if (fontFile.size() == 0 || fontName.size() == 0)
    {
        return;
    }

    for (int i = 0; i < fontNode.GetNumChildren(); ++i)
    {
        auto matNode = fontNode(i);
        if (matNode.GetName() == std::string("material"))
        {
            std::string matName = "font-material-" + fontName;
            CMaterial *mat = new CMaterial(matNode);
            mat->setName(matName);
            mm->add(matName, mat);
            m_material = mat;
            break;
        }
    }

    std::string fontPath;
    size_t pathEnd = fontFile.find_last_of('\\');
    if (pathEnd == fontFile.npos)
    {
        pathEnd = fontFile.find_last_of('/');
    }

    if (pathEnd != fontFile.npos)
    {
        fontPath = fontFile.substr(0, pathEnd+1);
    }

    CXMLTreeNode ff;
    if (!ff.LoadFile(fontFile.c_str()))
    {
        DEBUG_ASSERT(false);
        return;
    }

    CXMLTreeNode font = ff["font"];

    CXMLTreeNode common = font["common"];

    CXMLTreeNode info = font["info"];

    Vect2f pageSize(common.GetFloatProperty("scaleW", 0, false), common.GetFloatProperty("scaleH", 0, false));

    m_fontSize = info.GetFloatProperty( "size", 0, false );

    DEBUG_ASSERT( m_fontSize != 0);

    m_lineHeight = common.GetFloatProperty( "lineHeight", m_fontSize, false );

    m_base = common.GetFloatProperty( "base", m_fontSize, false );

    CXMLTreeNode pages = font["pages"];

    for (int i = 0; i < pages.GetNumChildren(); ++i)
    {
        auto page = pages(i);
        if (page.GetName() == std::string("page"))
        {
            std::string texFile = page.GetPszProperty("file", "", false);
            DEBUG_ASSERT(texFile.size() > 0);
            texFile = fontPath + texFile;
            CTexture *tex = new CTexture();
            tex->load(texFile, false);
            tm->add(tex->getName(), tex);
            m_pages.push_back(tex);
        }
    }

    auto chars = font["chars"];

    for (int i = 0; i < chars.GetNumChildren(); ++i)
    {
        auto ch = chars(i);
        if (ch.GetName() != std::string("char"))
        {
            continue;
        }
        uchar chId = ch.GetIntProperty("id");

        CharDesc_t cdesc;
        cdesc.offset = Vect2f(ch.GetFloatProperty("xoffset", 0, false), ch.GetFloatProperty("yoffset", 0, false));
        cdesc.page = ch.GetIntProperty("page");
        cdesc.size = Vect2f(ch.GetFloatProperty("width", 0, false), ch.GetFloatProperty("height", 0, false));
        cdesc.xAdvance = ch.GetFloatProperty("xadvance", 0, false);

//.........这里部分代码省略.........