www.pudn.com > sancedit.rar > ControlDialog.cpp

// TestDialog.cpp : implementation file 
// 
 
#include "stdafx.h" 
#include "MapGen.h" 
#include "OgreFrameWork.h" 
#include "ControlDialog.h" 
 
#include "OgreXMLPrerequisites.h" 
#include "OgreStringConverter.h" 
#pragma once 
 
//#ifdef _DEBUG 
//#define new DEBUG_NEW 
//#undef THIS_FILE 
//static char THIS_FILE[] = __FILE__; 
//#endif 
 
///////////////////////////////////////////////////////////////////////////// 
// CControlDialog dialog 
 
 
CControlDialog::CControlDialog(CWnd* pParent /*=NULL*/) 
	: CDialog(CControlDialog::IDD, pParent) 
{ 
	m_Edit = NULL; 
	m_bInit = FALSE; 
	m_NumberOfNodes = 0; 
	m_SelectedNodeName[0] = 0; 
	//{{AFX_DATA_INIT(CControlDialog) 
	//}}AFX_DATA_INIT 
} 
 
 
void CControlDialog::DoDataExchange(CDataExchange* pDX) 
{ 
	CDialog::DoDataExchange(pDX); 
	//{{AFX_DATA_MAP(CControlDialog) 
	//}}AFX_DATA_MAP 
} 
 
 
BEGIN_MESSAGE_MAP(CControlDialog, CDialog) 
	//{{AFX_MSG_MAP(CControlDialog) 
	ON_WM_SIZE() 
	ON_NOTIFY(TVN_SELCHANGED, IDC_EDIT2, OnSelchangedEdit2) 
	ON_BN_CLICKED(IDC_ROTATE, OnRotate) 
	ON_BN_CLICKED(IDC_POSITION, OnPosition) 
	ON_BN_CLICKED(IDC_SCALE, OnScale) 
	ON_BN_CLICKED(IDC_DELETE, OnDelete) 
	//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CControlDialog message handlers 
 
void CControlDialog::OnSize(UINT nType, int cx, int cy)  
{ 
	CDialog::OnSize(nType, cx, cy); 
 
	if(!m_bInit) 
		return; 
 
 
 
	CRect TopHalf; 
	GetClientRect(TopHalf); 
	TopHalf.bottom = TopHalf.bottom / 2; 
	TopHalf.DeflateRect(5,5); 
	CRect BottomHalf; 
	GetClientRect(BottomHalf); 
	BottomHalf.top = BottomHalf.bottom / 2; 
	BottomHalf.DeflateRect(5,5); 
 
	m_Edit = (CTreeCtrl*)GetDlgItem(IDC_EDIT2); 
	m_Edit->MoveWindow(TopHalf); 
 
 
 
//IDC_BOTTOM_FRAME 
	CRect  BottomFrame; 
	CPoint Delta; 
	GetDlgItem(IDC_BOTTOM_FRAME)->GetWindowRect(BottomFrame); 
	CRect  buttonrect; 
	GetDlgItem(IDC_DELETE)->GetWindowRect(buttonrect); 
	Delta.x = buttonrect.left - BottomFrame.left; 
	Delta.y = buttonrect.top - BottomFrame.top; 
 
	char str[128]; 
	sprintf(str,"%d %d",Delta.x,Delta.y); 
//	AfxMessageBox(str); 
	 
	RECT rc; 
	GetDlgItem(IDC_DELETE)->GetClientRect(&rc); 
	//GetDlgItem(IDC_DELETE)->MoveWindow(Delta.x,Delta.y + BottomHalf.top,rc.right,rc.bottom); 
//	GetDlgItem(IDC_DELETE)->MoveWindow(0+Delta.x,BottomHalf.top+Delta.y,rc.right,rc.bottom); 
 
} 
 
CControlDialog* CControlDialog::m_Inst = NULL; 
 
 
BOOL CControlDialog::OnInitDialog()  
{ 
	CDialog::OnInitDialog(); 
 
	m_Inst = this; 
 
	CRect sz; 
	GetClientRect(sz); 
	sz.DeflateRect(5,5); 
	 
/*	m_bInit = TRUE; 
	m_Edit = (CTreeCtrl*)GetDlgItem(IDC_EDIT2); 
 
	HTREEITEM i1 = m_Edit->InsertItem("Root 1"); 
	m_Edit->InsertItem("Branch 1", i1); 
	m_Edit->InsertItem("Branch 2", i1); 
	m_Edit->InsertItem("Branch 3", i1); 
	HTREEITEM i2 = m_Edit->InsertItem("Root 2"); 
	m_Edit->InsertItem("Branch 1", i2); 
	m_Edit->InsertItem("Branch 2", i2); 
	m_Edit->InsertItem("Branch 3", i2); 
	HTREEITEM i3 = m_Edit->InsertItem("Root 3"); 
	m_Edit->InsertItem("Branch 1", i3); 
	m_Edit->InsertItem("Branch 2", i3); 
	m_Edit->InsertItem("Branch 3", i3); 
*/ 
	return TRUE;  // return TRUE unless you set the focus to a control 
	// EXCEPTION: OCX Property Pages should return FALSE 
} 
 
void CControlDialog::OnOK()  
{ 
	// TODO: Add extra validation here 
	 
	//	CDialog::OnOK(); 
} 
 
bool CControlDialog::IsUniqueEntityNode(char *entityName,char *nodeName) { 
	 
	 
	int i; 
	for (i = 0; i < m_NumberOfNodes; i++)  
	{ 
		if (m_vNodeCollection[i].isactive)  
		{ 
			if (strcmpi(m_vNodeCollection[i].nodename,nodeName) == 0)  
			{ 
				return false; 
			} 
			if (strcmpi(m_vNodeCollection[i].entityname,entityName) == 0)  
			{ 
				return false; 
			} 
		} 
	} 
	 
	 
	return true; 
} 
 
 
bool CControlDialog::AddNode(char *meshFile,char *entityName,char *nodeName) 
{ 
 
	if (IsUniqueEntityNode(entityName,nodeName) == false) return false; 
 
	COgreFrameWork::GetInstance()->PlaceMeshAtCamera(meshFile,entityName,nodeName); 
	 
	nodeinfo_struct nodeinfo; 
	strcpy(nodeinfo.meshfile,meshFile); 
	strcpy(nodeinfo.entityname,entityName); 
	strcpy(nodeinfo.nodename,nodeName); 
	nodeinfo.isactive = true; 
 
	m_NumberOfNodes++; 
	m_vNodeCollection.push_back(nodeinfo); 
	 
	m_Edit = (CTreeCtrl*)GetDlgItem(IDC_EDIT2); 
 
	 
	HTREEITEM i1 = m_Edit->InsertItem(nodeName); 
	 
	m_Edit->SelectItem(i1); 
	return true; 
} 
 
void CControlDialog::OnSelchangedEdit2(NMHDR* pNMHDR, LRESULT* pResult)  
{ 
	NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR; 
	// TODO: Add your control notification handler code here 
	CTreeCtrl *pTree = (CTreeCtrl*)GetDlgItem(IDC_EDIT2); 
	HTREEITEM hItem = pTree->GetSelectedItem(); 
	CString selectedNode = pTree->GetItemText(hItem); 
//	AfxMessageBox(selectedNode); 
	strcpy(m_SelectedNodeName,(LPCTSTR)selectedNode); 
	 
// update fields in dialog 
	char str[128]; 
	float pos[3]; 
	COgreFrameWork::GetInstance()->GetNodePosition(m_SelectedNodeName,pos); 
	sprintf(str,"X: %3.3f",pos[0]); 
	GetDlgItem(IDC_STATIC_TX)->SetWindowText(str); 
	sprintf(str,"Y: %3.3f",pos[1]); 
	GetDlgItem(IDC_STATIC_TY)->SetWindowText(str); 
	sprintf(str,"Z: %3.3f",pos[2]); 
	GetDlgItem(IDC_STATIC_TZ)->SetWindowText(str); 
 
	float scale[3]; 
	COgreFrameWork::GetInstance()->GetNodeScale(m_SelectedNodeName,scale); 
	sprintf(str,"X: %3.3f",scale[0]); 
	GetDlgItem(IDC_STATIC_SX)->SetWindowText(str); 
	sprintf(str,"Y: %3.3f",scale[1]); 
	GetDlgItem(IDC_STATIC_SY)->SetWindowText(str); 
	sprintf(str,"Z: %3.3f",scale[2]); 
	GetDlgItem(IDC_STATIC_SZ)->SetWindowText(str); 
	 
	 
	COgreFrameWork::GetInstance()->HighLight(m_SelectedNodeName,true); 
	 
	GetDlgItem(IDC_STATIC_NODENAME)->SetWindowText(m_SelectedNodeName); 
	int index = CollectionIndexFromName(m_SelectedNodeName); 
	GetDlgItem(IDC_STATIC_MESHFILE)->SetWindowText(m_vNodeCollection[index].meshfile); 
 
	*pResult = 0; 
} 
 
void CControlDialog::OnRotate()  
{ 
	// TODO: Add your control notification handler code here 
	m_eEditMode = eROTATE; 
	CButton *radio; 
	radio = (CButton *)GetDlgItem(IDC_RADIO1); 
	radio->SetCheck(1); 
	radio = (CButton *)GetDlgItem(IDC_RADIO2); 
	radio->SetCheck(0); 
	radio = (CButton *)GetDlgItem(IDC_RADIO3); 
	radio->SetCheck(0); 
} 
 
void CControlDialog::OnPosition()  
{ 
	// TODO: Add your control notification handler code here 
	m_eEditMode = eTRANSLATE; 
	CButton *radio; 
	radio = (CButton *)GetDlgItem(IDC_RADIO1); 
	radio->SetCheck(0); 
	radio = (CButton *)GetDlgItem(IDC_RADIO2); 
	radio->SetCheck(1); 
	radio = (CButton *)GetDlgItem(IDC_RADIO3); 
	radio->SetCheck(0); 
} 
 
void CControlDialog::OnScale()  
{ 
	// TODO: Add your control notification handler code here 
	m_eEditMode = eSCALE; 
	CButton *radio; 
	radio = (CButton *)GetDlgItem(IDC_RADIO1); 
	radio->SetCheck(0); 
	radio = (CButton *)GetDlgItem(IDC_RADIO2); 
	radio->SetCheck(0); 
	radio = (CButton *)GetDlgItem(IDC_RADIO3); 
	radio->SetCheck(1); 
} 
 
void CControlDialog::OnDelete()  
{ 
	// find the selected node 
	CTreeCtrl *pTree = (CTreeCtrl*)GetDlgItem(IDC_EDIT2); 
	HTREEITEM hItem = pTree->GetSelectedItem(); 
	if (hItem == NULL) { 
		AfxMessageBox("Select a Node from the tree to delete"); 
		return; 
	} 
	CString selectedNode = pTree->GetItemText(hItem); 
	char *pStr = (char *)(LPCTSTR)selectedNode; 
	 
	int nindex = CollectionIndexFromName(pStr); 
 
	if (nindex < 0) { 
		AfxMessageBox("Node not found"); 
		return; 
	} 
 
	// set the node in the collection as not active 
	m_vNodeCollection[nindex].isactive = false; 
	// delete the node from the scene manager in ogre 
	COgreFrameWork::GetInstance()->DeleteNode(pStr); 
	// delete the item from the tree 
	pTree->DeleteItem(hItem); 
	 
} 
 
int CControlDialog::CollectionIndexFromName(char *nodeName) 
{ 
	int i; 
	for (i = 0; i < m_NumberOfNodes; i++) 
	{ 
		if (m_vNodeCollection[i].isactive)  
		{ 
			if (strcmpi(m_vNodeCollection[i].nodename,nodeName) == 0)  
			{ 
				return i; 
			} 
		} 
	} 
	return -1;	 
} 
 
bool CControlDialog::SaveFile(LPCTSTR filename) 
{ 
	FILE *outfile; 
	outfile = fopen(filename,"wt"); 
	if (outfile == NULL) return false; 
 
	int i; 
	for (i = 0; i < m_NumberOfNodes; i++)  
	{ 
		if (m_vNodeCollection[i].isactive)  
		{ 
			fprintf(outfile,"%s\n",m_vNodeCollection[i].nodename); 
			fprintf(outfile,"%s\n",m_vNodeCollection[i].entityname); 
			fprintf(outfile,"%s\n",m_vNodeCollection[i].meshfile); 
			char *ptrNodeName = m_vNodeCollection[i].nodename; 
			float q[4]; 
			float pos[3]; 
			float scale[3]; 
			COgreFrameWork::GetInstance()->GetNodePosition(ptrNodeName,pos); 
			COgreFrameWork::GetInstance()->GetNodeQuaternion(ptrNodeName,q); 
			COgreFrameWork::GetInstance()->GetNodeScale(ptrNodeName,scale); 
			fprintf(outfile,"%f %f %f %f\n",q[0],q[1],q[2],q[3]); // quaternion 
			fprintf(outfile,"%f %f %f\n",pos[0],pos[1],pos[2]); // position 
			fprintf(outfile,"%f %f %f\n",scale[0],scale[1],scale[2]);	// scale 
		} 
	} 
	fclose(outfile); 
	return true; 
} 
 
void CControlDialog::Serialize(CArchive &ar) 
{ 
	int i; 
	char str[256]; 
 
	CFile *cfile = ar.GetFile(); 
 
	if (ar.IsStoring()) 
	{ 
		//ExportXMLScene(ar); 
		return; 
 
 
 
		sprintf(str,"%d\r\n",m_NumberOfNodes); 
		ar.WriteString(str); 
		for (i = 0; i < m_NumberOfNodes; i++) { 
			if (m_vNodeCollection[i].isactive) { 
				sprintf(str,"%s\r\n",m_vNodeCollection[i].nodename); 
				ar.WriteString(str); 
				sprintf(str,"%s\r\n",m_vNodeCollection[i].entityname); 
				ar.WriteString(str); 
				sprintf(str,"%s\r\n",m_vNodeCollection[i].meshfile); 
				ar.WriteString(str); 
				char *ptrNodeName = m_vNodeCollection[i].nodename; 
				float q[4]; 
				float pos[3]; 
				float scale[3]; 
				COgreFrameWork::GetInstance()->GetNodePosition(ptrNodeName,pos); 
				COgreFrameWork::GetInstance()->GetNodeQuaternion(ptrNodeName,q); 
				COgreFrameWork::GetInstance()->GetNodeScale(ptrNodeName,scale); 
				sprintf(str,"%f %f %f\r\n",pos[0],pos[1],pos[2]);		// position 
				ar.WriteString(str); 
				sprintf(str,"%f %f %f %f\r\n",q[0],q[1],q[2],q[3]);		// quaternion 
				ar.WriteString(str); 
				sprintf(str,"%f %f %f\r\n",scale[0],scale[1],scale[2]);	// scale 
				ar.WriteString(str); 
			} 
		} 
	} 
	else 
	{ 
		return; 
		// first delete all nodes currently in scene 
		for (i = 0; i < m_NumberOfNodes; i++) { 
			if (m_vNodeCollection[i].isactive) { 
				COgreFrameWork::GetInstance()->DeleteNode(m_vNodeCollection[i].nodename); 
			} 
		} 
		m_NumberOfNodes = 0; 
		m_vNodeCollection.clear(); 
		// delete the items from the tree 
		CTreeCtrl *pTree = (CTreeCtrl*)GetDlgItem(IDC_EDIT2); 
		pTree->DeleteAllItems(); 
 
		// TODO: add loading code here 
		char nodename[256]; 
		char entityname[256]; 
		char meshfile[256]; 
		int number_of_nodes; 
		ar.ReadString(str,255); 
		sscanf(str,"%d",&number_of_nodes); 
		for (i = 0; i < number_of_nodes; i++) { 
			ar.ReadString(str,255); 
			sscanf(str,"%s",nodename); 
			ar.ReadString(str,255); 
			sscanf(str,"%s",entityname); 
			ar.ReadString(str,255); 
			sscanf(str,"%s",meshfile); 
			AddNode(meshfile,entityname,nodename); 
 
			float q[4]; 
			float pos[3]; 
			float scale[3]; 
			ar.ReadString(str,255); 
			sscanf(str,"%f %f %f",&pos[0],&pos[1],&pos[2]); 
			ar.ReadString(str,255); 
			sscanf(str,"%f %f %f %f",&q[0],&q[1],&q[2],&q[3]); 
			ar.ReadString(str,255); 
			sscanf(str,"%f %f %f",&scale[0],&scale[1],&scale[2]); 
			COgreFrameWork::GetInstance()->SetNodePosition(nodename,pos); 
			COgreFrameWork::GetInstance()->SetNodeQuaternion(nodename,q); 
			COgreFrameWork::GetInstance()->SetNodeScale(nodename,scale); 
		} 
	} 
} 
 
void CControlDialog::ExportXMLScene(char *filename) 
{ 
	int i; 
	char str[256]; 
	 
	//CFile *cfile = ar.GetFile(); 
	//char filename[FILENAME_MAX]; 
	//strcpy(filename,cfile->GetFileName()); 
	//ar.Abort(); 
 
	sprintf(str,"%d",m_NumberOfNodes); 
 
			TiXmlDocument* mXMLDoc; 
			mXMLDoc = new TiXmlDocument(); 
			if(mXMLDoc==NULL) 
				return; 
			mXMLDoc->InsertEndChild(TiXmlElement("scene")); 
			TiXmlElement* rootNode = mXMLDoc->RootElement(); 
			 
			TiXmlElement* objects_Node =  
				rootNode->InsertEndChild(TiXmlElement("objects"))->ToElement(); 
			objects_Node->SetAttribute("numberof", m_NumberOfNodes); 
 
 
 
	for (i = 0; i < m_NumberOfNodes; i++) { 
		if (m_vNodeCollection[i].isactive) { 
					TiXmlElement* objectNode =  
						objects_Node->InsertEndChild(TiXmlElement("object"))->ToElement(); 
 
			sprintf(str,"%s",m_vNodeCollection[i].nodename); 
					objectNode->SetAttribute("name", str); 
 
					TiXmlElement* nodeName1 =  
						objectNode->InsertEndChild(TiXmlElement("node"))->ToElement(); 
					nodeName1->SetAttribute("name", str); 
 
			sprintf(str,"%s",m_vNodeCollection[i].entityname); 
 
					TiXmlElement* nodeName2 =  
						objectNode->InsertEndChild(TiXmlElement("entity"))->ToElement(); 
					nodeName2->SetAttribute("name", str); 
			 
			sprintf(str,"%s",m_vNodeCollection[i].meshfile); 
 
					TiXmlElement* nodeName3 =  
						objectNode->InsertEndChild(TiXmlElement("meshfile"))->ToElement(); 
					nodeName3->SetAttribute("name", str); 
			 
			 
			char *ptrNodeName = m_vNodeCollection[i].nodename; 
			float q[4]; 
			float pos[3]; 
			float scale[3]; 
			COgreFrameWork::GetInstance()->GetNodePosition(ptrNodeName,pos); 
			COgreFrameWork::GetInstance()->GetNodeQuaternion(ptrNodeName,q); 
			COgreFrameWork::GetInstance()->GetNodeScale(ptrNodeName,scale); 
 
					TiXmlElement* quaternionNode =  
						objectNode->InsertEndChild(TiXmlElement("quaternion"))->ToElement(); 
			sprintf(str,"%f",q[0]);	 
					quaternionNode->SetAttribute("x", str); 
			sprintf(str,"%f",q[1]);	 
					quaternionNode->SetAttribute("y", str); 
			sprintf(str,"%f",q[2]);	 
					quaternionNode->SetAttribute("z", str); 
			sprintf(str,"%f",q[3]);	 
					quaternionNode->SetAttribute("w", str); 
 
					TiXmlElement* positionNode =  
						objectNode->InsertEndChild(TiXmlElement("position"))->ToElement(); 
			sprintf(str,"%f",pos[0]);	 
					positionNode->SetAttribute("x", str); 
			sprintf(str,"%f",pos[1]);	 
					positionNode->SetAttribute("y", str); 
			sprintf(str,"%f",pos[2]);	 
					positionNode->SetAttribute("z", str); 
 
					TiXmlElement* scaleNode =  
						objectNode->InsertEndChild(TiXmlElement("scale"))->ToElement(); 
			sprintf(str,"%f",scale[0]);	 
					scaleNode->SetAttribute("x", str); 
			sprintf(str,"%f",scale[1]);	 
					scaleNode->SetAttribute("y", str); 
			sprintf(str,"%f",scale[2]);	 
					scaleNode->SetAttribute("z", str); 
 
		} 
	} 
					mXMLDoc->SaveFile(filename); 
					//delete mXMLDoc; 
} 
 
bool CControlDialog::importXMLScene(char *filename) 
{ 
	int i; 
	char str[256]; 
		// first delete all nodes currently in scene 
		for (i = 0; i < m_NumberOfNodes; i++)  
		{ 
			if (m_vNodeCollection[i].isactive)  
			{ 
				COgreFrameWork::GetInstance()->DeleteNode(m_vNodeCollection[i].nodename); 
			} 
		} 
		m_NumberOfNodes = 0; 
		m_vNodeCollection.clear(); 
		// delete the items from the tree 
		CTreeCtrl *pTree = (CTreeCtrl*)GetDlgItem(IDC_EDIT2); 
		pTree->DeleteAllItems(); 
 
//////////////////////////////////////////////////////////////// 
 
	 
		/* 
		////////////////////////////////////////////////// 
			// open the xml scene file 
				TiXmlDocument* mXMLDoc; 
				mXMLDoc = new TiXmlDocument(filename); 
				mXMLDoc->LoadFile(); 
				 
				TiXmlElement* sceneNode;		 
				TiXmlElement* objectsNode;		 
				TiXmlElement* rootElem = mXMLDoc->RootElement(); 
 
 
				sceneNode = rootElem->FirstChildElement("scene"); 
				//if (sceneNode == NULL) return false; 
 
 
 
 
		// TODO: add loading code here 
		char nodename[256]; 
		char entityname[256]; 
		char meshfile[256]; 
		int number_of_nodes; 
        objectsNode = rootElem->FirstChildElement("objects"); 
		if (objectsNode == NULL) return false; 
		number_of_nodes = StringConverter::parseInt(objectsNode->Attribute("numberof")); 
 
		for (TiXmlElement* smElem = objectsNode->FirstChildElement(); 
			smElem != 0; smElem = smElem->NextSiblingElement())  
		{ 
 
				// get the node name, entity name, and meshfile name 
				TiXmlElement* node = smElem->FirstChildElement("node"); 
				TiXmlElement* entity = smElem->FirstChildElement("entity");				 
				TiXmlElement* meshfile = smElem->FirstChildElement("meshfile");		 
				 
				strcpy(nodename,node->Attribute("name")); 
 
				AddNode((char*)meshfile->Attribute("name"),(char*)entity->Attribute("name"),nodename); 
 
				float q[4]; 
				float pos[3]; 
				float s[3]; 
 
				// set the position of the node 
				TiXmlElement* position = smElem->FirstChildElement("position");	 
				pos[0] = StringConverter::parseReal(position->Attribute("x")); 
				pos[1] = StringConverter::parseReal(position->Attribute("y")); 
				pos[2] = StringConverter::parseReal(position->Attribute("z")); 
								 
				// set the quaternion of the node 
				TiXmlElement* quaternion = smElem->FirstChildElement("quaternion");	 
				q[0] = StringConverter::parseReal(quaternion->Attribute("x")); 
				q[1] = StringConverter::parseReal(quaternion->Attribute("y")); 
				q[2] = StringConverter::parseReal(quaternion->Attribute("z")); 
				q[3] = StringConverter::parseReal(quaternion->Attribute("w")); 
				 
				// set the scale of the node 
				TiXmlElement* scale = smElem->FirstChildElement("scale");	 
				s[0] = StringConverter::parseReal(scale->Attribute("x")); 
				s[1] = StringConverter::parseReal(scale->Attribute("y")); 
				s[2] = StringConverter::parseReal(scale->Attribute("z")); 
 
				// send these values to Ogre 
				COgreFrameWork::GetInstance()->SetNodePosition(nodename,pos); 
				COgreFrameWork::GetInstance()->SetNodeQuaternion(nodename,q); 
				COgreFrameWork::GetInstance()->SetNodeScale(nodename,s); 
		} 
 
 
*/ 
 
 
		TiXmlDocument* mXMLDoc; 
				mXMLDoc = new TiXmlDocument(filename); 
				mXMLDoc->LoadFile(); 
				 
				TiXmlElement* sceneNode;		 
				TiXmlElement* objectsNode;		 
				TiXmlElement* rootElem = mXMLDoc->RootElement(); 
				 
				 
				sceneNode = rootElem->FirstChildElement("scene"); 
				//if (sceneNode == NULL) return false; 
				 
				 
				 
				 
				// TODO: add loading code here 
				SceneNode *pEnt; 
				char nodename[256]; 
				char entityname[256]; 
				char meshfilename[256]; 
				int number_of_nodes; 
				Entity *ent; 
 
				 
 
				 
				objectsNode = rootElem->FirstChildElement("objects"); 
				if (objectsNode == NULL) return false; 
				number_of_nodes = StringConverter::parseInt(objectsNode->Attribute("numberof")); 
			//	printf("ÓÐ%d¸ö½Úµã\n",number_of_nodes); 
				for (TiXmlElement* smElem = objectsNode->FirstChildElement(); 
				smElem != 0; smElem = smElem->NextSiblingElement())  
				{ 
					 
					// get the node name, entity name, and meshfile name 
					TiXmlElement* node = smElem->FirstChildElement("node"); 
					TiXmlElement* entity = smElem->FirstChildElement("entity");				 
					TiXmlElement* meshfile = smElem->FirstChildElement("meshfile");		 
					 
					strcpy(nodename,node->Attribute("name")); 
					strcpy(entityname,entity->Attribute("name")); 
					strcpy(meshfilename,meshfile->Attribute("name")); 
				//	printf(nodename); 
				//	printf(":\n"); 
					AddNode((char*)meshfile->Attribute("name"),(char*)entity->Attribute("name"),nodename); 
					 
					 
					 
					float q[4]; 
					float pos[3]; 
					float s[3]; 
					 
					// set the position of the node 
					TiXmlElement* position = smElem->FirstChildElement("position");	 
					pos[0] = StringConverter::parseReal(position->Attribute("x")); 
					pos[1] = StringConverter::parseReal(position->Attribute("y")); 
					pos[2] = StringConverter::parseReal(position->Attribute("z")); 
			 
				 
 
					// set the quaternion of the node 
					TiXmlElement* quaternion = smElem->FirstChildElement("quaternion");	 
					q[0] = StringConverter::parseReal(quaternion->Attribute("x")); 
					q[1] = StringConverter::parseReal(quaternion->Attribute("y")); 
					q[2] = StringConverter::parseReal(quaternion->Attribute("z")); 
					q[3] = StringConverter::parseReal(quaternion->Attribute("w")); 
			 
					 
					// set the scale of the node 
					TiXmlElement* scale = smElem->FirstChildElement("scale");	 
					s[0] = StringConverter::parseReal(scale->Attribute("x")); 
					s[1] = StringConverter::parseReal(scale->Attribute("y")); 
					s[2] = StringConverter::parseReal(scale->Attribute("z")); 
				 
					 
					// send these values to Ogre 
					//	cOgreFramework::GetInstance()->SetNodePosition(nodename,pos); 
					//	cOgreFramework::GetInstance()->SetNodeQuaternion(nodename,q); 
					//	cOgreFramework::GetInstance()->SetNodeScale(nodename,s); 
					 
				 
				 
 
 
	 
				}	 
			 
 
				 
 
	return true; 
} 
 
/* check for multiple instances of the node name given... if there are 
   multiple instances then inc instance number and modify nodename */ 
void CControlDialog::incNodeInstance(char *nodeName) 
{ 
	int i; 
	char snumber[256]; 
	int highest_number = 0; 
	for (i = 0; i < m_NumberOfNodes; i++) { 
		if (m_vNodeCollection[i].isactive) { 
			if (strncmp(m_vNodeCollection[i].nodename,nodeName,strlen(nodeName)) == 0) { 
				// nodename found 
 
				// if these two nodes are identical then add a number 1 to the node name 
				if (strlen(nodeName) == strlen(m_vNodeCollection[i].nodename)) { 
					strcat(nodeName,"1"); 
					return; 
				} 
				strcpy(snumber,&m_vNodeCollection[i].nodename[strlen(nodeName)]); 
				int j; 
				for (j = 0; j < strlen(snumber); j++) { 
					if (isdigit(snumber[j]) == 0) snumber[j] = 0; 
				} 
				int current_instance = atoi(snumber); 
				if (highest_number < current_instance) highest_number = current_instance; 
			} 
		} 
	} 
	if (highest_number != 0)  
	{ 
		sprintf(snumber,"%d",highest_number+1); 
		strcat(nodeName,snumber); 
	} else  
	{ 
		// node name not found so make nodename with a 1 added on the end of the name,  
		//		this will be the first 
		strcat(nodeName,"1"); 
	} 
	 
} 
 
void CControlDialog::ClearScene() 
{ 
	int i; 
	char str[256]; 
		// first delete all nodes currently in scene 
		for (i = 0; i < m_NumberOfNodes; i++)  
		{ 
			if (m_vNodeCollection[i].isactive)  
			{ 
				COgreFrameWork::GetInstance()->DeleteNode(m_vNodeCollection[i].nodename); 
			} 
		} 
		m_NumberOfNodes = 0; 
		m_vNodeCollection.clear(); 
		// delete the items from the tree 
		CTreeCtrl *pTree = (CTreeCtrl*)GetDlgItem(IDC_EDIT2); 
		pTree->DeleteAllItems(); 
		 
}