C++ KString类代码示例

// --------
// Strings
// --------
void KStrings::SplitString(	const KString&	String,
							LPCTSTR			pSplitter,
							bool			bAddEmpty,
							bool			bClearFirst)
{
	if(bClearFirst)
		Clear();

	const size_t szSplitterLength = _tcslen(pSplitter);

	size_t szPos = 0;
	for(;;)
	{
		size_t szOldPos = szPos;
		szPos = String.Find(pSplitter, szPos);
		if(szPos == UINT_MAX)
		{
			if(bAddEmpty || szOldPos < String.GetLength())
				*AddLast() = String.Mid(szOldPos);

			break;
		}

		if(bAddEmpty || szPos > szOldPos)
			*AddLast() = String.Mid(szOldPos, szPos - szOldPos), szPos += szSplitterLength;
	}
}

bool SaveScene(KFbxSdkManager* pSdkManager, KFbxDocument* pScene, const char* pFilename, int pFileFormat, bool pEmbedMedia)
{
    int lMajor, lMinor, lRevision;
    bool lStatus = true;

    // Create an exporter.
    KFbxExporter* lExporter = KFbxExporter::Create(pSdkManager, "");

    if( pFileFormat < 0 || pFileFormat >= pSdkManager->GetIOPluginRegistry()->GetWriterFormatCount() )
    {
        // Write in fall back format in less no ASCII format found
        pFileFormat = pSdkManager->GetIOPluginRegistry()->GetNativeWriterFormat();

        //Try to export in ASCII if possible
        int lFormatIndex, lFormatCount = pSdkManager->GetIOPluginRegistry()->GetWriterFormatCount();

        for (lFormatIndex=0; lFormatIndex<lFormatCount; lFormatIndex++)
        {
            if (pSdkManager->GetIOPluginRegistry()->WriterIsFBX(lFormatIndex))
            {
                KString lDesc =pSdkManager->GetIOPluginRegistry()->GetWriterFormatDescription(lFormatIndex);
                char *lASCII = "ascii";
                if (lDesc.Find(lASCII)>=0)
                {
                    pFileFormat = lFormatIndex;
                    break;
                }
            }
        }
    }

    // Set the export states. By default, the export states are always set to 
    // true except for the option eEXPORT_TEXTURE_AS_EMBEDDED. The code below 
    // shows how to change these states.

    IOS_REF.SetBoolProp(EXP_FBX_MATERIAL,        true);
    IOS_REF.SetBoolProp(EXP_FBX_TEXTURE,         true);
    IOS_REF.SetBoolProp(EXP_FBX_EMBEDDED,        pEmbedMedia);
    IOS_REF.SetBoolProp(EXP_FBX_SHAPE,           true);
    IOS_REF.SetBoolProp(EXP_FBX_GOBO,            true);
    IOS_REF.SetBoolProp(EXP_FBX_ANIMATION,       true);
    IOS_REF.SetBoolProp(EXP_FBX_GLOBAL_SETTINGS, true);

    // Initialize the exporter by providing a filename.
    if(lExporter->Initialize(pFilename, pFileFormat, pSdkManager->GetIOSettings()) == false)
    {
        common->Warning("Call to KFbxExporter::Initialize() failed. Error returned: %s\n\n\n", lExporter->GetLastErrorString());
        return false;
    }

    KFbxSdkManager::GetFileFormatVersion(lMajor, lMinor, lRevision);
    common->Printf("FBX version number for this version of the FBX SDK is %d.%d.%d\n\n", lMajor, lMinor, lRevision);

    // Export the scene.
    lStatus = lExporter->Export(pScene); 

    // Destroy the exporter.
    lExporter->Destroy();
    return lStatus;
}

void InitializeSdkObjects(KFbxSdkManager*& pSdkManager, KFbxScene*& pScene)
{
    // The first thing to do is to create the FBX SDK manager which is the 
    // object allocator for almost all the classes in the SDK.
    pSdkManager = KFbxSdkManager::Create();

    if (!pSdkManager)
    {
        printf("Unable to create the FBX SDK manager\n");
        exit(0);
    }

	// create an IOSettings object
	KFbxIOSettings * ios = KFbxIOSettings::Create(pSdkManager, IOSROOT );
	pSdkManager->SetIOSettings(ios);

	// Load plugins from the executable directory
	KString lPath = KFbxGetApplicationDirectory();
#if defined(KARCH_ENV_WIN)
	KString lExtension = "dll";
#elif defined(KARCH_ENV_MACOSX)
	KString lExtension = "dylib";
#elif defined(KARCH_ENV_LINUX)
	KString lExtension = "so";
#endif
	pSdkManager->LoadPluginsDirectory(lPath.Buffer(), lExtension.Buffer());

    // Create the entity that will hold the scene.
    pScene = KFbxScene::Create(pSdkManager,"");
}

KString KString::FormattedV(LPCTSTR pFormat, va_list ArgList)
{
	KString String;
	String.FormatV(pFormat, ArgList);

	return String;
}

KString KString::Upper() const
{
	KString String = *this;

	_tcsupr(String.GetDataPtr());

	return String;
}

KString KString::Lower() const
{
	KString String = *this;

	_tcslwr(String.GetDataPtr());

	return String;
}

/**
 * Print an attribute.
 */
void PrintAttribute(FbxNodeAttribute* pAttribute) {
    if(!pAttribute) return;
 
    KString typeName = GetAttributeTypeName(pAttribute->GetAttributeType());
    KString attrName = pAttribute->GetName();
    PrintTabs();
    // Note: to retrieve the chararcter array of a KString, use its Buffer() method.
    printf("<attribute type='%s' name='%s'/>\n", typeName.Buffer(), attrName.Buffer());
}

// Print an attribute
void FBXParser::printAttribute(KFbxNodeAttribute const & pAttribute) const{
  if(!&pAttribute){ return; }

  KString typeName = getAttributeTypeName(pAttribute.GetAttributeType());
  KString attrName = pAttribute.GetName();
  printTabs();
  cout << "<attribute type= " << typeName.Buffer() << " name= " << attrName.Buffer();
  cout << "/>" << endl;
}

KString KString::Formatted(LPCTSTR pFormat, ...)
{
	va_list ArgList;
	va_start(ArgList, pFormat);

	KString String;
	String.FormatV(pFormat, ArgList);

	va_end(ArgList);

	return String;
}

int Scene::getCurrentAnimationIndex()
{
    int index = 0;
    for(int i = 0; i < animationNames.GetCount(); i++) {
        KString* currentName = animationNames[i];
        KString activeName = KFbxGet<KString>(fbxScene->ActiveAnimStackName);

        if(currentName->Compare(activeName) == 0) {
            index = i;
        }
    }
    return index;
}

void DisplayDouble(const char* pHeader, double pValue, const char* pSuffix /* = "" */)
{
	KString lString;
	KString lFloatValue = (float) pValue;

	lFloatValue = pValue <= -HUGE_VAL ? "-INFINITY" : lFloatValue.Buffer();
	lFloatValue = pValue >=  HUGE_VAL ?  "INFINITY" : lFloatValue.Buffer();

	lString = pHeader;
	lString += lFloatValue;
	lString += pSuffix;
	lString += "\n";
	printf(lString);
}

void ParseHTTPHeaderCommand(const KString&		s,
							THTTPHeaderCommand&	RCommand)
{
	int i = 0;

	i = s.Find(TEXT(":"));

	if(i == -1)
		RCommand.m_Command = s, RCommand.m_Content = TEXT("");
	else
		RCommand.m_Command = s.Left(i), RCommand.m_Content = s.Mid(i + 1);

	RCommand.m_Command = RCommand.m_Command.Trim();
	RCommand.m_Content = RCommand.m_Content.Trim();
}

bool TextureManager::LoadTextureFromFile(const KString & pFilePath, unsigned int & pTextureObject)
{
	int		compo;
	GLenum		Format;
	int		w;
	int		h;
	GLbyte*		Bits;

	if (pFilePath.Right(3).Upper() == "TGA")
	{

		Bits  = gltReadTGABits(pFilePath, &w, &h, &compo, &Format);

		if (Bits != NULL)
		{
			glGenTextures(1, &pTextureObject);
			glBindTexture(GL_TEXTURE_2D, pTextureObject);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
			glTexImage2D(GL_TEXTURE_2D, 0, compo, w, h, 0, Format,
					GL_UNSIGNED_BYTE, Bits);

			return true;
		}
	}

	return false;
}

void KStrings::SplitToTokens(	const KString&	String,
								LPCTSTR			pDelimeters,
								bool			bClearFirst)
{
	if(bClearFirst)
		Clear();

	KString TempString = String;

	TCHAR *pToken;
	for(pToken = _tcstok(TempString.GetDataPtr(), pDelimeters) ;
		pToken ;
		pToken = _tcstok(NULL, pDelimeters))
	{
		*AddLast() = pToken;
	}
}

// -------
// Tokens
// -------
KString TTokens::Process(const KString& String) const
{
	KString DstString;

	for(size_t szStart = 0 ; szStart < String.GetLength() ; )
	{
		// Scanning for the closest token starting at 'szStart'
		const TToken*	pClosestToken = NULL;
		size_t			szClosestTokenPos;

		for(size_t i = 0 ; i < GetN() ; i++)
		{
			const TToken& CurToken = GetDataRef(i);

			size_t szPos = String.Find(CurToken.m_SrcString, szStart);
			if(szPos == UINT_MAX)
				continue;

			if(	pClosestToken == NULL		||
				szPos < szClosestTokenPos	||
				szPos == szClosestTokenPos &&
					CurToken.m_SrcString.GetLength() >
						pClosestToken->m_SrcString.GetLength())
			{
				pClosestToken = &CurToken, szClosestTokenPos = szPos;
			}
		}
		
		if(pClosestToken == NULL) // no more tokens found
		{
			DstString += String.Mid(szStart); // adding leftovers
			break;
		}

		DstString += String.Mid(szStart, szClosestTokenPos - szStart); // adding pre-token part
		DstString += pClosestToken->m_DstString; // adding token replacement
		
		// Forwarding 'szStart' to the end of just substed token
		szStart = szClosestTokenPos + pClosestToken->m_SrcString.GetLength();
	}

	return DstString;
}