www.pudn.com > zfxcengine-0.1.0.zip > ceMesh.cpp

// $Id: ceMesh.cpp,v 1.2 2005/09/22 16:45:45 kimmi Exp $ 
//////////////////////////////////////////////////////////////////////////////// 
// 
//  Module:     Core 
//  File:       ceMesh.cpp 
//  Created:    25.10.2004 21:00:37 
//  Author:     Enrico 
//	Licence:    See licence file in root 
//  Last Mod:	$Id: ceMesh.cpp,v 1.2 2005/09/22 16:45:45 kimmi Exp $ 
// 
//////////////////////////////////////////////////////////////////////////////// 
#include "Geometry/ceMesh.h" 
#include "Core/ceDebug.h" 
#include "Core/ceMemManager.h" 
#include "Core/ceResourceManager.h" 
 
namespace ZFXCE { 
	//------------------------------------------------------------------------------ 
	ceMesh::ceMesh() 
	{ 
		// TODO: add submeshes for all different primitive type 
		this->m_PrimType= CE_RS_PRIM_TRIANGLES; 
		m_bUpdate = true; 
		m_uiSize = 0; 
		m_pResTypeName = NULL; 
		m_pResTypeName = new char[6]; 
		ce_assert (NULL != m_pResTypeName); 
		strncpy(m_pResTypeName, "ceMesh", 6); 
		m_pScratchFile = NULL; 
	} 
	//------------------------------------------------------------------------------ 
	ceMesh::~ceMesh() 
	{ 
		Release(); 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::Release() 
	{ 
		PUSH_FUNCTION; 
 
		m_Vertices.clear(); 
		for(INT i=0; i < CE_RS_TEXUNITMAX; i++) 
			m_TexCoords[i].clear(); 
		m_Normals.clear(); 
 
		for (UINT m=0; m < m_LinkedMeshes.size(); ++m) 
			delete m_LinkedMeshes[m]; 
			 
		m_LinkedMeshes.clear(); 
		m_uiSize = 0; 
		m_bUpdate = true; 
		delete [] m_pResTypeName; 
		 
		m_pResTypeName = NULL; 
	} 
	//------------------------------------------------------------------------------ 
/*	DWORD ceMesh::GetSize() 
	{ 
		if (m_bUpdate) { 
			// XXX: Evil! <- Under win donīt compile 
			//m_uiSize = ((const ceMesh*) this)->GetSize(); 
			return (DWORD) 0; 
		} 
		 
		m_bUpdate = FALSE; 
		 
		return m_uiSize; 
	}*/ 
	//------------------------------------------------------------------------------ 
	size_t ceMesh::GetSize() 
	{ 
		PUSH_FUNCTION; 
 
		const size_t sV3 = sizeof(ceVec3f); 
		size_t s = m_Vertices.size() * sV3; 
		s += m_Normals.size() * sV3; 
		s += m_LinkedMeshes.size() * sizeof(ceMesh); 
		for (UINT t=0; t < CE_RS_TEXUNITMAX; ++t)  
			s += m_TexCoords[t].size() * sizeof(ceVec2f); 
		m_uiSize =(UINT) s; 
		 
		return s; 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::Load() 
	{ 
		PUSH_FUNCTION; 
 
		ce_assert (NULL != m_pResMgr); 
		if (NULL == m_pScratchFile) { 
			m_pResMgr->Load(this); 
		} 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::Unload() 
	{ 
		PUSH_FUNCTION; 
		 
		ce_assert (NULL != m_pResMgr); 
		if (NULL == m_pScratchFile) { 
			 
		} 
	} 
	//------------------------------------------------------------------------------ 
	bool ceMesh::IsLoaded() const 
	{ 
		PUSH_FUNCTION; 
		 
		return true; 
	} 
	//------------------------------------------------------------------------------ 
	std::vector ceMesh::GetVertices() const 
	{ 
		PUSH_FUNCTION; 
		 
		return m_Vertices; 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::SetVertices(std::vector vVertices) 
	{ 
		PUSH_FUNCTION; 
		 
		m_Vertices = vVertices; 
	} 
	//------------------------------------------------------------------------------ 
	std::vector &ceMesh::GetFaces() 
	{ 
		PUSH_FUNCTION; 
 
		return m_Faces; 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::SetFaces(std::vector vFaces) 
	{ 
		PUSH_FUNCTION; 
 
		m_Faces = vFaces; 
	} 
	//------------------------------------------------------------------------------ 
	std::vector &ceMesh::GetTexCoords(UINT n) 
	{ 
		PUSH_FUNCTION; 
		 
		ce_assert (n < 0 || n >= CE_RS_TEXUNITMAX); 
		return m_TexCoords[n]; 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::SetTexCoords(const UINT uiIndex, std::vector vTexCoords) 
	{ 
		PUSH_FUNCTION; 
		 
		ce_assert (uiIndex > CE_RS_TEXUNITMAX); 
		m_TexCoords[uiIndex] = vTexCoords; 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::SetTexCoordsByName(const std::string strName,  
		std::vector v) 
	{ 
		PUSH_FUNCTION; 
 
		vector::iterator it; 
		int i=0; 
		for (it = m_TextureNames.begin(); it != m_TextureNames.end(); ++it) { 
			if ((*it) == strName) { 
				m_TexCoords[i] = v; 
				return; 
			} 
			++i; 
		} 
		m_TextureNames.push_back(strName); 
		m_TexCoords[m_TextureNames.size()-1] = v; 
	} 
	//------------------------------------------------------------------------------ 
	vector &ceMesh::GetTextureNames() 
	{ 
		PUSH_FUNCTION; 
		return m_TextureNames; 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::SetTextureNames(std::vector vTextureNames) 
	{ 
		PUSH_FUNCTION; 
		m_TextureNames = vTextureNames; 
	} 
	//------------------------------------------------------------------------------ 
	std::vector &ceMesh::GetNormals() 
	{ 
		PUSH_FUNCTION; 
 
		return m_Normals; 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::SetNormals(std::vector vNormals) 
	{ 
		PUSH_FUNCTION; 
 
		m_Normals = vNormals; 
	} 
	//------------------------------------------------------------------------------ 
	size_t ceMesh::GetNLinkedMeshes() 
	{ 
		return m_LinkedMeshes.size(); 
	} 
	//------------------------------------------------------------------------------ 
	ceMesh* ceMesh::GetLinkedMesh(UINT nr) 
	{ 
		if(nr < 0 || nr >= m_LinkedMeshes.size() ) 
			return NULL; 
 
		return m_LinkedMeshes[nr]; 
	} 
	//------------------------------------------------------------------------------ 
	std::string ceMesh::GetTexture(UINT nr) 
	{ 
		if (nr < 0 || nr > CE_RS_TEXUNITMAX) 
			return "none"; 
 
		return "none"; 
	} 
	//------------------------------------------------------------------------------ 
	bool ceMesh::CalculateLOD(UINT MaxIndices) 
	{ 
		PUSH_FUNCTION; 
	 
		return false; 
	} 
	//------------------------------------------------------------------------------ 
	bool ceMesh::Optimize()  
	{ 
		PUSH_FUNCTION; 
		 
		// TODO 
		return false; 
	} 
	//------------------------------------------------------------------------------ 
	std::string ceMesh::GetName() 
	{ 
		PUSH_FUNCTION; 
	 
		return "XXX: ceMesh::GetName() not implemented."; 
	} 
	//------------------------------------------------------------------------------ 
	bool ceMesh::CalculateNormals() 
	{ 
		PUSH_FUNCTION; 
		// TODO 
 
		return false; 
	} 
	//------------------------------------------------------------------------------ 
	std::vector &ceMesh::GetTTangents() 
	{ 
		PUSH_FUNCTION; 
		// TODO 
		ce_assert ( false && "Not yet implemented"); 
		// XXX: memleak 
		return *(new std::vector()); 
	} 
	//------------------------------------------------------------------------------ 
	bool ceMesh::CalculateTangents() 
	{ 
		PUSH_FUNCTION; 
		// TODO 
 
		return false; 
	} 
	//------------------------------------------------------------------------------ 
	std::vector &ceMesh::GetSTangents() 
	{ 
		PUSH_FUNCTION; 
		 
		ce_assert ( false && "Not yet implemented"); 
		// XXX: memleak 
		return *(new std::vector()); 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::SetTTangents(std::vector vTangents) 
	{ 
		PUSH_FUNCTION; 
 
		// TODO: Add managed tangents 
	} 
	//------------------------------------------------------------------------------ 
	void ceMesh::Dump() 
	{ 
		PUSH_FUNCTION; 
 
		cout << "Name : " << m_Name << endl; 
		cout << "Whole size         : " << (UINT) GetSize() << endl;; 
		cout << "Number of vertices : " << (UINT) m_Vertices.size() << endl; 
		cout << "Number of indices  : " << (UINT) m_vIndices.size() << endl; 
		cout << "Number of normals  : " << (UINT) m_Normals.size() << endl; 
		cout << "Number of textures : " << (UINT) m_TextureNames.size() << endl; 
		cout << "Number of faces    : " << (UINT) m_Faces.size() << endl;	 
		cout << "Number of Colors   : " << (UINT) m_Colors.size() << endl; 
	} 
	//------------------------------------------------------------------------------ 
 
} // Namespace ZFXCE