C++ CXMLNode::GetAttribute方法代码示例

_MEMBER_FUNCTION_IMPL(xml, getNodeAttribute)
{
    // Get the XML instance pointer
    CXML * pXML = sq_getinstance< CXML* >( pVM );

    // Is the xml instance valid?
    if( pXML )
    {
        // Get the XML node pointer
        CXMLNode * pNode = sq_getpointer< CXMLNode* >( pVM, 2 );

        // Is the node valid?
        if( pNode )
        {
            // Get the attribute name
            const char * szName;
            sq_getstring( pVM, 3, &szName );

            // Get the attribute value
            const char * szValue = pNode->GetAttribute( szName );

            sq_pushstring( pVM, szValue, strlen(szValue) );
            return 1;
        }
    }

    sq_pushbool( pVM, false );
    return 1;
}

Bool CMaterialResource::Init()
{
	CXMLDocument document;
	document.Load( m_FilePath.c_str() );

	CXMLNode rootNode = document.GetRootNode();

	//Read out textures
	CXMLNode childNode = rootNode.GetChildNode( "Texture2D" );

	while ( childNode.IsEmpty() == false )
	{
		CXMLAttribute attribute = childNode.GetAttribute( "Hash" );
		const Uint hash = (Uint)strtoul( attribute.GetValue(), NULL, 0 );
		AddDependentHash( hash );
		childNode = childNode.GetNextSibling();
	}

	if ( m_DependenciesLeft == 0 )
	{
		return true;
	}

	return false;
}

	CXMLNode* CFactory::GetPrototypeXML(const string &AName)
	{
		CPrototype *proto = Get<CPrototype>(AName);
		if (!proto)
		{
			Log("ERROR", "No such prototype: '%s'", AName.c_str());
			return NULL;
		}

		CXMLNode *xml = proto->GetRootNode();
		if (xml->IsErroneous() || !xml->HasAttribute("Name") || xml->GetAttribute("Name") != AName)
		{
			Log("ERROR", "Prototype '%s' XML contains an error", AName.c_str());
			return NULL;
		}

		return xml;
	}

/**
 * expand parallel.
 *
 *  copies expand attribute from old node to new node and call function
 *  recursively for children.
 *  stops, if number of children is not equal.
 *
 * @param           rtNodeNew: new node
 * @param           rtNodeNew: old node
 * @return          -
 * @exception       -
 * @see             -
*/
void CInstanceTree::ExpandParallel(CXMLNode& rtNodeNew, CXMLNode& rtNodeOld)
{
    CXMLNode        tNodeChildNew;
    CXMLNode        tNodeChildOld;
    CXMLNodeList    tChildListNew;
    CXMLNodeList    tChildListOld;

    long            lNumChildrenNew;
    long            lNumChildrenOld;
    long            lChild;

    CString         strExpanded;

    if(rtNodeOld.GetAttribute(CE_XMLATTR_EXPANDED, strExpanded))
    {
        rtNodeNew.SetAttribute(CE_XMLATTR_EXPANDED, strExpanded);
    }

    if(!rtNodeNew.GetChildNodeList(tChildListNew) || !rtNodeOld.GetChildNodeList(tChildListOld))
    {
        return;
    }

    lNumChildrenNew = tChildListNew.GetLength();
    lNumChildrenOld = tChildListOld.GetLength();

    if(lNumChildrenNew != lNumChildrenOld)
    {
        return;
    }

    for(lChild = 0; lChild < lNumChildrenNew; ++lChild)
    {
        if(tChildListNew.Item(lChild, tNodeChildNew) && tChildListOld.Item(lChild, tNodeChildOld))
        {
            ExpandParallel(tNodeChildNew, tNodeChildOld);
        }
    }
}

void CCameraSceneNode::Load( const CXMLNode& a_XMLNode )
{
	LoadCommonValues( a_XMLNode );
	LoadChildren( a_XMLNode );

	// Do own stuff
	m_Camera = new CCamera();

	float FOV, screenHeight, screenWidth, aspectRatio, nearPlaneDist, farPlaneDist;

	CXMLAttribute attribute = a_XMLNode.GetAttribute( "Active" );
	m_Active = (bool)atoi( attribute.GetValue( "0" ) );
	attribute = a_XMLNode.GetAttribute( "FOV" );
	FOV = (float)atof( attribute.GetValue( "60" ) );
	attribute = a_XMLNode.GetAttribute( "ScrHeight" );
	screenHeight = (float)atof( attribute.GetValue( "3" ) );
	attribute = a_XMLNode.GetAttribute( "ScrWidth" );
	screenWidth = (float)atof( attribute.GetValue( "4" ) );
	attribute = a_XMLNode.GetAttribute( "Near" );
	nearPlaneDist = (float)atof( attribute.GetValue( "0.1" ) );
	attribute = a_XMLNode.GetAttribute( "Far" );
	farPlaneDist = (float)atof( attribute.GetValue( "100.0" ) );

	aspectRatio = screenWidth / screenHeight;

	printf( "Loaded camera %s, FOV %.1f, Aspect %.4f, Near %.5f, Far %.3f, Active %i\n", m_Name.c_str(), FOV, aspectRatio, nearPlaneDist, farPlaneDist, m_Active );

	glm::mat4 perspectiveMatrix = glm::perspective( FOV, aspectRatio, nearPlaneDist, farPlaneDist );
	perspectiveMatrix[1].y *= -1.0f;
	m_Camera->SetProjectionMatrix( perspectiveMatrix );
	m_Camera->SetTransformationMatrix( m_WorldMatrix );
	m_Camera->SetPosition( m_Position );
	m_Camera->SetRotation( m_Rotation );
	m_Camera->SetFarPlaneDistance( farPlaneDist );
	m_Camera->SetNearPlaneDistance( nearPlaneDist );
}

bool CResourceManager::StartResource( const char * szResource )
{
	// Is the resource already running?
	if( IsResourceRunning( szResource ) )
	{
		CLogFile::Printf( "Failed to start resource '%s'. (Resource is already running)", szResource );
		return false;
	}

	// Get the resource path
	String strPath( "resources/%s", szResource );

	// Does the path not exist?
	if( !SharedUtility::Exists( strPath.Get() ) )
	{
		CLogFile::Printf( "Failed to load resource '%s'. (Path doesn't exist)", szResource );
		return false;
	}

	// Get the meta file
	String strMeta( "%s/meta.xml", strPath.Get() );

	// Does the file not exist?
	if( !SharedUtility::Exists( strMeta.Get() ) )
	{
		CLogFile::Printf( "Failed to load resource '%s'. (Can't find meta.xml)", szResource );
		return false;
	}

	// Load the XML file
	CXML * pFile = new CXML( strMeta.Get() );

	// Is the file invalid?
	if( !pFile )
		return false;

	// Create the resource structure
	SResource resource;
	resource.strName.Set ( szResource );
	resource.strPath = strPath;
	resource.iScripts = 0;
	resource.iFiles = 0;

	// Get the root node
	CXMLNode * pRootNode = pFile->GetRootNode();

	// Is the root node invalid?
	if( !pRootNode )
	{
		// Delete the xml file
		SAFE_DELETE( pFile );
		return false;
	}

	// Get all the root node children
	std::list< CXMLNode* > children = pRootNode->GetChildren();

	// Loop all the children in the root node
	for( std::list< CXMLNode* >::iterator iter = children.begin(); iter != children.end(); iter++ )
	{
		// Get a pointer to the current node
		CXMLNode * pCurNode = *iter;

		// Is the current node valid?
		if( pCurNode )
		{
			// Get the current node type
			const char * szNodeType = pCurNode->GetName();

			// Get the current node data
			const char * szNodeData = pCurNode->GetValue();

			// Is this node a script?
			if( !strcmp( szNodeType, "script" ) )
			{
				// Create the script struct
				SScript script;

				// Set the script name
				script.strName.Set ( szNodeData );

				// Set the script type
				const char * szScriptType = pCurNode->GetAttribute( "type" );

				// Update the path
				strPath.Format( "resources/%s/%s", szResource, szScriptType  );

				// Is this a client script?
				if( !strcmp( szScriptType, "client" ) )
				{
					// Load the clientscript
					if( !pCore->GetClientScriptingManager()->Start( szNodeData, strPath ) )
						continue;

					// Set the script type
					script.eType = E_SCRIPT_CLIENT;

					// Increase the resource script count
					resource.iScripts++;
				}
//.........这里部分代码省略.........

bool CBanManager::Load( const char * szFileName )
{
	bool bParse = true;

	// Create the xml ban file instance
	m_pBanFile = new CXML( szFileName );

	// Get the root node
	m_pRootNode = m_pBanFile->GetRootNode();

	// Is the root node invalid?
	if( !m_pRootNode )
	{
		// Create the root node
		m_pRootNode = m_pBanFile->CreateRootNode( "bans" );

		// Save the file
		m_pBanFile->Save();

		// Mark as no need to parse
		bParse = false;
	}

	// Should we parse the file?
	if( bParse )
	{
		//
		CXMLNode * pNode = NULL;
		unsigned int uiCount = m_pRootNode->GetChildCount();

		// Is there no bans?
		if( uiCount == 0 )
			return true;

		// Loop over all children
		for( unsigned int i = 0; i < uiCount; i++ )
		{
			// Get the current node
			pNode = m_pRootNode->GetNode( i );

			// Is the node invalid?
			if( !pNode )
				continue;

			// Get the current node name
			const char * szName = pNode->GetName();

			// Is this a ban?
			if( !strcmp( szName, "ban" ) )
			{
				const char *szSerial = "", *szBanner = "", *szReason = "";
				unsigned long ulBanTime, ulUnbanTime;

				// Get the ban data
				szSerial = pNode->GetValue();
				szBanner = pNode->GetAttribute( "banner" );
				ulBanTime = (unsigned long)atol( pNode->GetAttribute( "time" ) );
				ulUnbanTime = (unsigned long)atol( pNode->GetAttribute( "unban" ) );
				szReason = pNode->GetAttribute( "reason" );

				// Add the ban to the manager
				Add( szSerial, szBanner, ulBanTime, ulUnbanTime, szReason, false );

				// Increase the total loaded bans
				m_iTotalBansLoaded++;
			}
		}

		// Mark as bans loaded
		m_bBansLoaded = true;

		// Pulse the ban manager
		Pulse( true );

		// Were any bans loaded?
		if( m_iTotalBansLoaded > 0 )
		{
			// Subtract the total purged bans from the total loaded.
			m_iTotalBansLoaded -= m_iTotalUnbans;

			// Did we purge ALL bans?
			if( m_iTotalBansLoaded == 0 )
				CLogFile::Printf( "Successfully purged %d bans.", m_iTotalUnbans );
			else
				CLogFile::Printf( "Successfully loaded %d bans. (%d purged)", m_iTotalBansLoaded, m_iTotalUnbans );

			// Reset the total unban count
			m_iTotalUnbans = 0;
		}

		return true;
	}

	return false;
}

void CMaterialResource::Load()
{
	m_IsLoaded = true;
	CXMLDocument document;
	document.Load( m_FilePath.c_str() );

	CXMLNode rootNode = document.GetRootNode();
	//Read out shaders
	CXMLNode childNode = rootNode.GetChildNode( "Shader" );
	CXMLAttribute attribute = childNode.GetAttribute( "File" );

	std::string shaderPath; shaderPath += "../Content/";
	shaderPath += attribute.GetValue();
	
	//Read out defines
	childNode = rootNode.GetChildNode( "ShaderDefine" );

	while ( childNode.IsEmpty() == false )
	{
		attribute = childNode.GetAttribute( "Name" );
		const Char* name = attribute.GetValue( "" );
		if ( strcmp( name, "" ) != 0 )
		{
			m_ShaderDefines.push_back( name );
		}
		childNode = childNode.GetNextSibling();
	}

	//Build hash
	Uint hash = HashString( shaderPath.c_str() );
	hash += m_ShaderDefines.size();
	for ( Uint i = 0; i < m_ShaderDefines.size(); ++i )
	{
		hash += HashString( m_ShaderDefines[i].c_str() );
	}

	CResource* shaderResource;
	if ( ( shaderResource = CResourceManager::GetInstance()->GetResourceByHash( hash ) ) == NULL )
	{
		shaderResource = CResourceManager::GetInstance()->AddShaderResource( shaderPath.c_str(), hash, m_ShaderDefines );
	}

	m_ShaderResource = (CShaderResource*)shaderResource;
	m_Shader = m_ShaderResource->GetShader();

	//Read terms
	childNode = rootNode.GetChildNode( "Terms" );
	//Emmisive
	CXMLNode termNode = childNode.GetChildNode( "Emissive" );
	attribute = termNode.GetAttribute( "R" ); m_EmissiveTerm.X = (Float)atof( attribute.GetValue() );
	attribute = termNode.GetAttribute( "G" ); m_EmissiveTerm.Y = (Float)atof( attribute.GetValue() );
	attribute = termNode.GetAttribute( "B" ); m_EmissiveTerm.Z = (Float)atof( attribute.GetValue() );
	//Diffuse
	termNode = childNode.GetChildNode( "Diffuse" );
	attribute = termNode.GetAttribute( "R" ); m_DiffuseTerm.X = (Float)atof( attribute.GetValue() );
	attribute = termNode.GetAttribute( "G" ); m_DiffuseTerm.Y = (Float)atof( attribute.GetValue() );
	attribute = termNode.GetAttribute( "B" ); m_DiffuseTerm.Z = (Float)atof( attribute.GetValue() );
	//Specular
	termNode = childNode.GetChildNode( "Specular" );
	attribute = termNode.GetAttribute( "R" ); m_SpecularTerm.X = (Float)atof( attribute.GetValue() );
	attribute = termNode.GetAttribute( "G" ); m_SpecularTerm.Y = (Float)atof( attribute.GetValue() );
	attribute = termNode.GetAttribute( "B" ); m_SpecularTerm.Z = (Float)atof( attribute.GetValue() );
	//Ambient
	termNode = childNode.GetChildNode( "Ambient" );
	attribute = termNode.GetAttribute( "R" ); m_AmbientTerm.X = (Float)atof( attribute.GetValue() );
	attribute = termNode.GetAttribute( "G" ); m_AmbientTerm.Y = (Float)atof( attribute.GetValue() );
	attribute = termNode.GetAttribute( "B" ); m_AmbientTerm.Z = (Float)atof( attribute.GetValue() );
	//Specular power
	termNode = childNode.GetChildNode( "SpecularPower" );	
	if ( termNode.IsEmpty() == false )
	{
		attribute = termNode.GetAttribute( "Value" ); 
		m_SpecularPower = (Float)atof( attribute.GetValue( "1.0f" ) );
	}

	termNode = childNode.GetChildNode( "Reflection" );	
	if ( termNode.IsEmpty() == false )
	{
		attribute = termNode.GetAttribute( "Value" ); 
		m_Reflection = (Float)atof( attribute.GetValue( "0.0f" ) );
	}

	termNode = childNode.GetChildNode( "Refraction" );	
	if ( termNode.IsEmpty() == false )
	{
		attribute = termNode.GetAttribute( "Value" ); 
		m_Refraction = (Float)atof( attribute.GetValue( "0.0f" ) );
	}	

	termNode = childNode.GetChildNode( "Transmittance" );	
	if ( termNode.IsEmpty() == false )
	{
		attribute = termNode.GetAttribute( "Value" ); 
		m_Transmittance = (Float)atof( attribute.GetValue( "0.0f" ) );
	}

	termNode = childNode.GetChildNode( "FresnelPower" );	
	if ( termNode.IsEmpty() == false )
	{
		attribute = termNode.GetAttribute( "Value" ); 
//.........这里部分代码省略.........

//.........这里部分代码省略.........
        CString     strTUserAddress;         // user connect info
        CString     strTConsoleAddress;      // console address
        CString     strTAssignedResource;    // assigned resource
        CString     strTSource;              // source file for add on action
        
        CString     strParseSource;         // parser source help var
        CString     strParseSourceNew;      // parser source
        CString     strInstType;             // type of the instance node

        CString     strIdPathTarg;          // id path of target node in target tree
        CString     strIdPathInst;          // id path of target instance in instance tree
        CString     strTargetId;
        CString     strWaitForTarget;
        
        strIdPathTarg = listNewTargets.GetNext(posNewTargets);

        strTargetId = strIdPathTarg;
        int iFind = strTargetId.ReverseFind(CE_XML_IDPATH_SEP_CHAR);
        ASSERT(iFind>0);
        if (iFind>0)
        {
            strTargetId = strTargetId.Mid(iFind+1);
        }

        // get target node
        ret = nodeTargetRoot.GetNodeFromIdPath(strIdPathTarg, nodeTarget);
        ASSERT(ret);
        if (!ret)
        {
            continue;
        }

        // get attributes of the target node
        nodeTarget.GetAttribute(CE_XMLATTR_TEXT, strTText);
        nodeTarget.GetAttribute(CE_XMLATTR_ID, strTId);
        nodeTarget.GetAttribute(CE_XMLATTR_TYPE, strTType);
        nodeTarget.GetAttribute(CE_XMLATTR_ADDR, strTAddress);
        nodeTarget.GetAttribute(CE_XMLATTR_USERADDR, strTUserAddress);
        nodeTarget.GetAttribute(CE_XMLATTR_CONSOLE_ADDR, strTConsoleAddress);
        nodeTarget.GetAttribute(CE_XMLATTR_RESOURCE, strTAssignedResource);
        nodeTarget.GetAttribute(CE_XMLATTR_SOURCE, strTSource);
        nodeTarget.GetAttribute(CE_XMLATTR_WAIT_TARGET_CONN , strWaitForTarget);

        strInstType = strTType + CE_XML_INST_ADD;
        strParseSource = strTId + _T(".") + CE_INSTANCE_EXT;
        strParseSourceNew = CString(CE_GEN_PATH) + _T("\\") + strTId + _T("\\") + strParseSource;

        // does node already exist in instance tree:
        TInstanceTargetInfo* pInstTargetInfo = NULL;
        CString strLowerId = strTargetId;
        strLowerId.MakeLower();
        if (m_mapInstanceTargets.Lookup(strLowerId, pInstTargetInfo))
        {
            // *** existing node ***
            ASSERT(pInstTargetInfo);
            pInstTargetInfo->bUsed = TRUE;
            nodeInstance = pInstTargetInfo->xmlNode;
            ret = nodeInstanceRoot.AppendChild(nodeInstance, TRUE);
            ASSERT(ret);

            // check if attributes have changed
            // get instance node attributes
            CString strInstText;
            CString strInstId;
            //CString strInstType;
            CString strInstAddress;

bool CCeWatchElement::LoadFromNode(CXMLNode& rtNode, CCeSymbol* pRootSymbol)
{
    bool bReturn = true;
	CString str;
    int iPos = -1;

	Init();

    rtNode.GetAttribute(CEWATCH_XMLATTR_EXPRESSION, str);
    iPos = str.Find(CEWATCH_EXP_EQ);
    if(iPos == -1) 
    {
        m_Name = str;
    }
    else
    {
        m_Name = str.Mid(iPos+1);
    }
	// 15.12.05 SIS >>
	// remove array range from name
	// otherwise it will be shown twice
	int iFound = m_Name.Find(_T(", ["));
	if(iFound != -1)
	{
		m_strIndexRange = m_Name.Mid(iFound);
		m_Name = m_Name.Left(iFound);
	}
	// 14.12.05 SIS <<

    m_Name.TrimLeft();
    m_Name.TrimRight();

    rtNode.GetAttribute(CEWATCH_XMLATTR_TYPE, str);

	CCeWatchType type;
	if (type.SetByName(str))
	{
		SetType(type);

        PresetHistory();

        //last value - don't read it
        rtNode.GetAttribute(CEWATCH_XMLATTR_VALUE, m_strValue);
        rtNode.GetAttribute(CEWATCH_XMLATTR_FORMAT, m_strFormat);
        rtNode.GetAttribute(CEWATCH_XMLATTR_EXPANDED, str);
        if(atoi(str) == 1)
        {
            m_bInitExpanded = true;
        }
		
        CXMLNodeList    tChildList;
        CXMLNode        tNodeChild;
		CCeWatchElement* pChild = NULL;

        if(rtNode.GetChildNodeList(tChildList))
        {
            long lNumChildren = tChildList.GetLength();
            for(long lChild = 0; lChild < lNumChildren; ++lChild)
            {
                tChildList.Item(lChild, tNodeChild);
				pChild = new CCeWatchElement();
				AddChild(pChild);
                bReturn &= pChild->LoadFromNode(tNodeChild, pRootSymbol);
            }
		}
	}
	if(!bReturn)
    {
		Init();
    }
    return bReturn;
}