Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/ColladaPlugin/src/OgreColladaGeometry.cpp @ 23

Last change on this file since 23 was 21, checked in by nicolasc, 17 years ago
added ogreode and Colladaplugin
File size: 31.7 KB

Rev	Line
[21]	1	/**
	2	* This source file is part of OgreColladaPlugin
	3	* an addon for OGRE (Object-oriented Graphics Rendering Engine)
	4	* For the latest info, see http://www.ogre3d.org/
	5	*
	6	* This program is free software; you can redistribute it and/or modify it under
	7	* the terms of the GNU Lesser General Public License as published by the Free Software
	8	* Foundation; either version 2 of the License, or (at your option) any later
	9	* version.
	10
	11	* This program is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	13	* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
	14
	15	* You should have received a copy of the GNU Lesser General Public License along with
	16	* this program; if not, write to the Free Software Foundation, Inc., 59 Temple
	17	* Place - Suite 330, Boston, MA 02111-1307, USA, or go to
	18	* http://www.gnu.org/copyleft/lesser.txt.
	19	*
	20	* @author Philipp Hartl
	21	* @see README
	22	*/
	23
	24	#include "OgreColladaGeometry.h"
	25	#include "OgreColladaDocument.h"
	26	#include "OgreColladaLibrary.h"
	27	#include "OgreColladaMaterial.h"
	28	#include "OgreColladaScene.h"
	29	#include "OgreColladaSyntax.h"
	30	#include "OgreColladaUtils.h"
	31
	32	#include "OgreSceneManager.h"
	33	#include "OgreMovableObject.h"
	34	#include "OgreMeshManager.h"
	35	#include "OgreSubMesh.h"
	36	#include "OgreEntity.h"
	37	#include "OgreStringConverter.h"
	38
	39	namespace Ogre
	40	{
	41	//-------------------------------------------------------------------------
	42	ColladaGeometry::ColladaGeometry(ColladaDocument doc, xmlNode n) : ColladaEntity(doc, n)
	43	{
	44	mOgreMesh = NULL;
	45	mEntityName = "";
	46	mBB = NULL;
	47	mBBReset = false;
	48	}
	49
	50	//-------------------------------------------------------------------------
	51	ColladaGeometry::~ColladaGeometry(void)
	52	{
	53	if (!mSources.empty())
	54	{
	55	for (ColladaGeometrySourcePtrVector::iterator i = mSources.begin(); i != mSources.end(); ++i)
	56	{
	57	(*i)->data.clear();
	58	OGRE_DELETE(*i);
	59	}
	60	mSources.clear();
	61	}
	62	if (!mVertexInputs.empty())
	63	{
	64	for (ColladaGeometryInputDataPtrVector::iterator i = mVertexInputs.begin(); i != mVertexInputs.end(); ++i)
	65	{
	66	// source already freed
	67	OGRE_DELETE(*i);
	68	}
	69	mVertexInputs.clear();
	70	}
	71	if (!mPolygons.empty())
	72	{
	73	for (ColladaGeometryPolygonPtrVector::iterator i = mPolygons.begin(); i != mPolygons.end(); ++i)
	74	{
	75	for (ColladaGeometryInputDataPtrVector::iterator j = (i)->inputs.begin(); j != (i)->inputs.end(); ++j)
	76	{
	77	// source already freed
	78	OGRE_DELETE(*j);
	79	}
	80	(*i)->inputs.clear();
	81	(*i)->material = NULL;
	82	OGRE_DELETE(*i);
	83	}
	84	mPolygons.clear();
	85	}
	86
	87	if (mOgreMesh != NULL)
	88	{
	89	for (ColladaGeometryOgreMeshIndexData::iterator it = mOgreMesh->indices.begin(); it != mOgreMesh->indices.end(); ++it)
	90	{
	91	OGRE_DELETE_ARRAY((*it)->indices);
	92	OGRE_DELETE(*it);
	93	}
	94	mOgreMesh->indices.clear();
	95	OGRE_DELETE_ARRAY(mOgreMesh->vertices);
	96	OGRE_DELETE(mOgreMesh);
	97	}
	98
	99	if (mBBReset) mBB = NULL;
	100	else OGRE_DELETE(mBB);
	101	}
	102
	103	//-------------------------------------------------------------------------
	104	void ColladaGeometry::calcBoundingBox(void)
	105	{
	106	if (!mBB)
	107	{
	108	// calculate a bounding box
	109	ColladaGeometrySource *src = mVertexInputs.at(0)->source;
	110
	111	float minX, minY, minZ, maxX, maxY, maxZ;
	112	minX = maxX = src->data.at(0);
	113	minY = maxY = src->data.at(1);
	114	minZ = maxZ = src->data.at(2);
	115
	116	for (uint i = 0; i < src->count; i++)
	117	{
	118	uint index = i * 3;
	119
	120	if (minX > src->data.at(index)) minX = src->data.at(index);
	121	if (minY > src->data.at(index + 1)) minY = src->data.at(index + 1);
	122	if (minZ > src->data.at(index + 2)) minZ = src->data.at(index + 2);
	123
	124	if (maxX < src->data.at(index)) maxX = src->data.at(index);
	125	if (maxY < src->data.at(index + 1)) maxY = src->data.at(index + 1);
	126	if (maxZ < src->data.at(index + 2)) maxZ = src->data.at(index + 2);
	127	}
	128
	129	mBB = new ColladaBoundingBox(Vector3(minX, minY, minZ), Vector3(maxX, maxY, maxZ));
	130	}
	131	}
	132
	133	//-------------------------------------------------------------------------
	134	void ColladaGeometry::createTriangleList(void)
	135	{
	136	// walk through all polygons, there must be at least one at index 0
	137	uint polygonCount = static_cast<uint>(mPolygons.size());
	138	ColladaGeometryPolygon *polygon = mPolygons.at(0);
	139	if (polygon == NULL) return;
	140
	141	// for simple life
	142	ColladaGeometryInputData *vertexInput = NULL;
	143	ColladaGeometryInputData *normalInput = NULL;
	144	ColladaGeometryInputData *texcoordInput = NULL;
	145
	146	// get all trivial sources through vertex inputs, one index array for all
	147	ColladaGeometryInputDataPtrVector::iterator it;
	148	for (it = mVertexInputs.begin(); it != mVertexInputs.end(); ++it)
	149	{
	150	if ((it)->semantic == ColladaGeometrySpecific::POSITION) vertexInput = it;
	151	if ((it)->semantic == ColladaGeometrySpecific::NORMAL) normalInput = it;
	152	if ((it)->semantic == ColladaGeometrySpecific::TEXCOORD) texcoordInput = it;
	153	}
	154
	155	// look for detailed normals and texcoords, each source with its own index data
	156	for (it = polygon->inputs.begin(); it != polygon->inputs.end(); ++it)
	157	{
	158	if ((it)->semantic == ColladaGeometrySpecific::NORMAL) normalInput = it;
	159	if ((it)->semantic == ColladaGeometrySpecific::TEXCOORD) texcoordInput = it;
	160	}
	161
	162	// vertex, normal, texcoord source counts
	163	uint vertexcount = static_cast<uint>(vertexInput->source->data.size());
	164	uint normalcount = 0;
	165	uint texcoordcount = 0;
	166	if (normalInput != NULL) normalcount = static_cast<uint>(normalInput->source->data.size());
	167	if (texcoordInput != NULL) texcoordcount = static_cast<uint>(texcoordInput->source->data.size());
	168
	169	// create new ogre mesh structure
	170	mOgreMesh = new ColladaGeometryOgreMesh();
	171	mOgreMesh->drawNormals = ((normalInput != NULL) && (normalcount > 0));
	172	// are there more normals per vertex?
	173	bool normalsEx = (mOgreMesh->drawNormals && (normalcount != vertexcount));
	174	mOgreMesh->drawTexCoords = ((texcoordInput != NULL) && (texcoordcount > 0));
	175	// more texcoords per vertex
	176	bool texcoordsEx = (mOgreMesh->drawTexCoords && (texcoordcount != vertexcount));
	177
	178	// calc stride size for vertex array
	179	uint stridesize = vertexInput->source->stride;
	180	if (mOgreMesh->drawNormals) stridesize += normalInput->source->stride;
	181	if (mOgreMesh->drawTexCoords) stridesize += texcoordInput->source->stride;
	182
	183	// how many triangles are in one polygon?
	184	// if there are more than one polygon per geometry, the amount should not change!
	185	uint trianglesppolygon = 1;
	186	uint i = 0;
	187	for (i = polygon->vertexCount; i > 3; i--) trianglesppolygon++;
	188
	189	/** simple case, each vertex has at maximum only one normal and/or one texture information
	190	* (vertexcount == normalcount == texcoordcount, all data have the same indices)
	191	* so we only have to triangulate the polygon primitive
	192	*/
	193	if (!normalsEx && !texcoordsEx)
	194	{
	195	// create space for the vertex array
	196	mOgreMesh->vertexCount = vertexInput->source->count;
	197	mOgreMesh->vertices = new float[mOgreMesh->vertexCount * stridesize];
	198
	199	// (1) fill up vertices with vertex (normal, texcoord) data
	200	// the mesh could be created anyway if polygonCount > 0
	201	uint offset = 0;
	202	for (i = 0; i < mOgreMesh->vertexCount; i++)
	203	{
	204	mOgreMesh->vertices[i * stridesize] = vertexInput->source->data[i * 3];
	205	mOgreMesh->vertices[i * stridesize + 1] = vertexInput->source->data[i * 3 + 1];
	206	mOgreMesh->vertices[i * stridesize + 2] = vertexInput->source->data[i * 3 + 2];
	207	mDoc->correctAxis(&mOgreMesh->vertices[i * stridesize]);
	208
	209	offset = 3;
	210	if (mOgreMesh->drawNormals)
	211	{
	212	mOgreMesh->vertices[i * stridesize + offset] = normalInput->source->data[i * 3];
	213	mOgreMesh->vertices[i * stridesize + offset + 1] = normalInput->source->data[i * 3 + 1];
	214	mOgreMesh->vertices[i * stridesize + offset + 2] = normalInput->source->data[i * 3 + 2];
	215	mDoc->correctAxis(&mOgreMesh->vertices[i * stridesize + offset]);
	216	offset += 3;
	217	}
	218
	219	if (mOgreMesh->drawTexCoords)
	220	{
	221	mOgreMesh->vertices[i * stridesize + offset] = texcoordInput->source->data[i * 2];
	222	mOgreMesh->vertices[i * stridesize + offset + 1] = texcoordInput->source->data[i * 2 + 1];
	223	}
	224	}
	225
	226	// (2) fill up indices array for each polygon primitive
	227	for (ColladaGeometryPolygonPtrVector::iterator it = mPolygons.begin(); it != mPolygons.end(); ++it)
	228	{
	229	polygon = *it;
	230
	231	// create enough space for the index array
	232	ColladaGeometryIndexData *tmpIndices = new ColladaGeometryIndexData();
	233	tmpIndices->count = trianglesppolygon * polygon->primitiveCount * 3;
	234	tmpIndices->indices = new unsigned short[tmpIndices->count];
	235	tmpIndices->material = ((it)->setMaterial) ? (it)->material->getId() : "";
	236
	237	// set vertexInput pointer at indices
	238	vertexInput = polygon->inputs.at(0);
	239
	240	offset = trianglesppolygon * 3;
	241	uint index = 0;
	242	for (i = 0; i < polygon->primitiveCount; i++)
	243	{
	244	index = offset * i;
	245
	246	// first triangle
	247	tmpIndices->indices[index] = vertexInput->indices[i * polygon->vertexCount];
	248	tmpIndices->indices[index + 1] = vertexInput->indices[i * polygon->vertexCount + 1];
	249	tmpIndices->indices[index + 2] = vertexInput->indices[i * polygon->vertexCount + 2];
	250
	251	// are there more than one triangle in one primitive?
	252	for (uint j = 1; j < trianglesppolygon; j++)
	253	{
	254	tmpIndices->indices[index + j * 3] = vertexInput->indices[i * polygon->vertexCount];
	255	tmpIndices->indices[index + j * 3 + 1] = vertexInput->indices[i * polygon->vertexCount + j + 1];
	256	tmpIndices->indices[index + j * 3 + 2] = vertexInput->indices[i * polygon->vertexCount + j + 2];
	257	}
	258	}
	259
	260	// save index array
	261	mOgreMesh->indices.push_back(tmpIndices);
	262	}
	263	}
	264	/** tricky case, each vertex can have more than one normal and/or texture
	265	* normals or texcoord arrays with different indices
	266	*/
	267	else
	268	{
	269	// space for vertex count
	270	mOgreMesh->vertexCount = 0;
	271	ColladaGeometryPolygonPtrVector::iterator it;
	272	for (it = mPolygons.begin(); it != mPolygons.end(); ++it)
	273	{
	274	// the vertexCount should not change!
	275	mOgreMesh->vertexCount += (it)->primitiveCount (*it)->vertexCount;
	276	}
	277	mOgreMesh->vertices = new float[mOgreMesh->vertexCount * stridesize];
	278
	279	for (it = mPolygons.begin(); it != mPolygons.end(); ++it)
	280	{
	281	polygon = (*it);
	282
	283	// create enough space for the index array
	284	ColladaGeometryIndexData *tmpIndices = new ColladaGeometryIndexData();
	285	tmpIndices->count = trianglesppolygon * polygon->primitiveCount * 3;
	286	tmpIndices->indices = new unsigned short[tmpIndices->count];
	287	tmpIndices->material = ((it)->setMaterial) ? (it)->material->getId() : "";
	288
	289	// get vertex indices
	290	intVector *vertexIndices = &polygon->inputs.at(0)->indices;
	291
	292	// get normal indices
	293	intVector *normalIndices = &normalInput->indices;
	294	if (!normalsEx) normalIndices = vertexIndices;
	295
	296	// get texture indices
	297	intVector *textureIndices = &texcoordInput->indices;
	298	if (!texcoordsEx) textureIndices = vertexIndices;
	299
	300	// fill up mVertices and mIndices array in one pass
	301	for (i = 0; i < polygon->primitiveCount; i++)
	302	{
	303	// starting index for one primitive
	304	uint pindex = i * polygon->vertexCount;
	305
	306	// (1) vertices
	307	uint j;
	308	for (j = 0; j < polygon->vertexCount; j++)
	309	{
	310	uint vindex = pindex + j; // vertex index
	311
	312	// vertex data
	313	mOgreMesh->vertices[vindex * stridesize] = vertexInput->source->data[vertexIndices->at(vindex) * 3];
	314	mOgreMesh->vertices[vindex * stridesize + 1] = vertexInput->source->data[vertexIndices->at(vindex) * 3 + 1];
	315	mOgreMesh->vertices[vindex * stridesize + 2] = vertexInput->source->data[vertexIndices->at(vindex) * 3 + 2];
	316	mDoc->correctAxis(&mOgreMesh->vertices[vindex * stridesize]);
	317
	318	uint offset = 3;
	319	if (mOgreMesh->drawNormals)
	320	{
	321	mOgreMesh->vertices[vindex * stridesize + offset] = normalInput->source->data[normalIndices->at(vindex) * 3];
	322	mOgreMesh->vertices[vindex * stridesize + offset + 1] = normalInput->source->data[normalIndices->at(vindex) * 3 + 1];
	323	mOgreMesh->vertices[vindex * stridesize + offset + 2] = normalInput->source->data[normalIndices->at(vindex) * 3 + 2];
	324	mDoc->correctAxis(&mOgreMesh->vertices[vindex * stridesize + offset]);
	325
	326	offset += 3;
	327	}
	328
	329	if (mOgreMesh->drawTexCoords)
	330	{
	331	mOgreMesh->vertices[vindex * stridesize + offset] = texcoordInput->source->data[textureIndices->at(vindex) * 2];
	332	mOgreMesh->vertices[vindex * stridesize + offset + 1] = texcoordInput->source->data[textureIndices->at(vindex) * 2 + 1];
	333	}
	334	}
	335
	336	// (2) indices
	337	uint iindex = i * trianglesppolygon * 3; // indices index
	338
	339	// first triangle
	340	tmpIndices->indices[iindex] = pindex;
	341	tmpIndices->indices[iindex + 1] = pindex + 1;
	342	tmpIndices->indices[iindex + 2] = pindex + 2;
	343
	344	// are there more than one triangle in one primitive?
	345	for (j = 1; j < trianglesppolygon; j++)
	346	{
	347	tmpIndices->indices[iindex + j * 3] = pindex;
	348	tmpIndices->indices[iindex + j * 3 + 1] = pindex + j + 1;
	349	tmpIndices->indices[iindex + j * 3 + 2] = pindex + j + 2;
	350	}
	351	}
	352
	353	// save index array
	354	mOgreMesh->indices.push_back(tmpIndices);
	355	}
	356	}
	357
	358	// TEST
	359	// printVertices(stridesize);
	360	// printIndices();
	361	}
	362
	363	//-------------------------------------------------------------------------
	364	MovableObject *ColladaGeometry::getOgreInstance(void) const
	365	{
	366	if (mOgreMesh != NULL && !mEntityName.empty())
	367	{
	368	// create hw-buffers and push the data there, material will be set too
	369	createOgreMesh();
	370
	371	return mDoc->getSceneManager()->createEntity(mEntityName, mId);
	372	}
	373
	374	return NULL;
	375	}
	376
	377	//-------------------------------------------------------------------------
	378	void ColladaGeometry::createOgreMesh(void) const
	379	{
	380	//if (MeshManager::getSingleton().getByName(mId) != static_cast<ResourcePtr>(NULL)) return;
	381	ResourcePtr p;
	382	if (MeshManager::getSingleton().getByName(mId) != p)
	383	return;
	384
	385	MeshPtr pMesh = MeshManager::getSingleton().createManual(mId, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
	386	pMesh->sharedVertexData = new VertexData();
	387	pMesh->sharedVertexData->vertexCount = mOgreMesh->vertexCount;
	388	VertexDeclaration *pVertexDecl = pMesh->sharedVertexData->vertexDeclaration;
	389
	390	size_t offset = 0;
	391
	392	// position
	393	pVertexDecl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
	394	offset += VertexElement::getTypeSize(VET_FLOAT3);
	395
	396	// normals
	397	if (mOgreMesh->drawNormals)
	398	{
	399	pVertexDecl->addElement(0, offset, VET_FLOAT3, VES_NORMAL);
	400	offset += VertexElement::getTypeSize(VET_FLOAT3);
	401	}
	402
	403	// colour (diffuse, specular)
	404
	405	// texture coordinates
	406	if (mOgreMesh->drawTexCoords)
	407	{
	408	pVertexDecl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES, 0);
	409	offset += VertexElement::getTypeSize(VET_FLOAT2);
	410	}
	411
	412	HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
	413	offset, pMesh->sharedVertexData->vertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
	414
	415	// set vertex buffer binding so buffer 0 is bound to our vertex buffer
	416	VertexBufferBinding* bind = pMesh->sharedVertexData->vertexBufferBinding;
	417	bind->setBinding(0, vbuf);
	418	// upload the vertex data to the card
	419	vbuf->writeData(0, vbuf->getSizeInBytes(), mOgreMesh->vertices, true);
	420
	421	// for each polygon create a new submesh, for multimaterial e.g.
	422	// submesh with index buffer
	423	for (ColladaGeometryOgreMeshIndexData::iterator it = mOgreMesh->indices.begin(); it != mOgreMesh->indices.end(); ++it)
	424	{
	425	SubMesh *pSubMesh = pMesh->createSubMesh();
	426	pSubMesh->indexData->indexCount = (*it)->count;
	427	pSubMesh->indexData->indexBuffer = HardwareBufferManager::getSingleton().createIndexBuffer(
	428	HardwareIndexBuffer::IT_16BIT, pSubMesh->indexData->indexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
	429	HardwareIndexBufferSharedPtr ibuf = pSubMesh->indexData->indexBuffer;
	430	// upload the index data
	431	ibuf->writeData(0, ibuf->getSizeInBytes(), (*it)->indices, true);
	432
	433	if (!(it)->material.empty()) pSubMesh->setMaterialName((it)->material);
	434	pSubMesh->useSharedVertices = true;
	435	pSubMesh->operationType = RenderOperation::OT_TRIANGLE_LIST;
	436	}
	437
	438	// there should be an AABB in every case, maybe overwritten from the collada scene node import
	439	// be careful by AABB if the object is duplicated and translated
	440	pMesh->_setBounds(mBB->getAABB());
	441	pMesh->_setBoundingSphereRadius(mBB->getRadius());
	442
	443	pMesh->load();
	444	}
	445
	446	//-------------------------------------------------------------------------
	447	bool ColladaGeometry::doImport(void)
	448	{
	449	if (mLoaded) return mStatus;
	450	else mLoaded = true;
	451
	452	// get <mesh> node, must occur exactly one time [1,1]
	453	xmlNode *mesh = ColladaUtils::getChildByTagName(mNode, CS_ELM_MESH);
	454	if (mesh != NULL) mStatus = importMesh(mesh);
	455
	456	// get <extra> nodes, can occur [0,*]
	457	// xmlNodePtrVector extras = ColladaUtils::getChildsByTagName(mNode, CS_ELM_EXTRA);
	458	// for (xmlNodePtrVector::iterator i = extras.begin(); i != extras.end(); ++i) importExtra((*i));
	459
	460	if (mStatus)
	461	{
	462	calcBoundingBox();
	463
	464	// create the vertices and indices by simple triangulation
	465	if (mType == POLYGONS \|\| mType == TRIANGLES) createTriangleList();
	466	}
	467
	468	return mStatus;
	469	}
	470
	471	//-------------------------------------------------------------------------
	472	void ColladaGeometry::importExtra(xmlNode *extraNode)
	473	{
	474	// not yet implemented
	475	}
	476
	477	//-------------------------------------------------------------------------
	478	bool ColladaGeometry::importMesh(xmlNode *meshNode)
	479	{
	480	bool bPrimitives = false;
	481
	482	// vertices must occur exactly one time
	483	if (!importVerticesNode(meshNode)) return false;
	484
	485	// look for polygon primitives
	486	bPrimitives = importPolygonsNodes(meshNode, CS_ELM_POLYGONS);
	487	if (bPrimitives)
	488	{
	489	mType = POLYGONS;
	490	return true;
	491	}
	492
	493	// triangles
	494	bPrimitives = importPolygonsNodes(meshNode, CS_ELM_TRIANGLES);
	495	if (bPrimitives)
	496	{
	497	mType = TRIANGLES;
	498	return true;
	499	}
	500
	501	return false;
	502	}
	503
	504	//-------------------------------------------------------------------------
	505	bool ColladaGeometry::importPolygonsNodes(xmlNode *meshNode, const String &primitive)
	506	{
	507	// there can be more than one <polygons> node, e.g. multi materials
	508	xmlNodePtrVector polygonsNodes = ColladaUtils::getChildsByTagName(meshNode, primitive);
	509	if (polygonsNodes.empty()) return false;
	510
	511	// walk through all <polygons>
	512	for (xmlNodePtrVector::iterator it = polygonsNodes.begin(); it != polygonsNodes.end(); ++it)
	513	{
	514	xmlNode polygonsNode = it;
	515
	516	ColladaGeometryPolygon *polygon = new ColladaGeometryPolygon();
	517
	518	// attribute material refers to a <material> node
	519	String material = ColladaUtils::getProperty(polygonsNode, CS_ATR_INPUT_MATERIAL);
	520	polygon->setMaterial = false;
	521	// search for material, get ptr
	522	if (!material.empty())
	523	{
	524	material.erase(0,1); // remove the # sign
	525	polygon->material = mDoc->getLibrary()->getMaterial(material);
	526	if (polygon->material != NULL)
	527	{
	528	// import material entity
	529	if (!(polygon->setMaterial = polygon->material->doImport()))
	530	{
	531	LogManager::getSingleton().logMessage("ColladaGeometry::importPolygonsNodes - loading of assigned material " + material + " failed! " + mId);
	532	}
	533	}
	534	else
	535	{
	536	LogManager::getSingleton().logMessage("ColladaGeometry::importPolygonsNodes - can't find assigned material with id " + material + "! " + mId);
	537	}
	538	}
	539
	540	// the number of polygon primitives
	541	String count = ColladaUtils::getProperty(polygonsNode, CS_ATR_COUNT);
	542	polygon->primitiveCount = (!count.empty()) ? static_cast<uint>(atoi(count.c_str())) : 0;
	543
	544	// walk through <param>, <input>, <p> childs
	545	xmlNode *c = NULL;
	546	for (c = polygonsNode->children; c != NULL; c = c->next)
	547	{
	548	if (c->type != XML_ELEMENT_NODE) continue;
	549	String tagname = (const char *)c->name;
	550
	551	// <param>, ignore it
	552	if (tagname == CS_ELM_PARAM) continue;
	553	// <input>
	554	else if (tagname == CS_ELM_INPUT)
	555	{
	556	// get semantic attribute
	557	String semantic = ColladaUtils::getProperty(c, CS_ATR_INPUT_SEMANTIC);
	558	ColladaGeometrySpecific::Semantic tmpsemantic = ColladaGeometrySpecific::getSemantic(semantic);
	559
	560	if (tmpsemantic == ColladaGeometrySpecific::VERTEX \|\|
	561	tmpsemantic == ColladaGeometrySpecific::NORMAL \|\|
	562	tmpsemantic == ColladaGeometrySpecific::TEXCOORD)
	563	{
	564	// if (tmpsemantic == ColladaGeometryInput::NORMAL) mhasFaceNormals = true;
	565	// if (tmpsemantic == ColladaGeometryInput::TEXCOORD) mhasFaceTexCoords = true;
	566
	567	String idx = ColladaUtils::getProperty(c, CS_ATR_IDX);
	568	String source = ColladaUtils::getProperty(c, CS_ATR_INPUT_SOURCE);
	569
	570	ColladaGeometrySource *gsource = NULL;
	571	// the source node points at <vertices>, already imported by importVerticesNode
	572	if (tmpsemantic != ColladaGeometrySpecific::VERTEX)
	573	{
	574	gsource = importSourceNode(ColladaUtils::getChildById(meshNode, source.c_str()));
	575	if (gsource == NULL)
	576	{
	577	LogManager::getSingleton().logMessage("ColladaGeometry::importVerticesNode - unable to find/import <source> with id " + source);
	578	continue;
	579	}
	580	}
	581
	582	// make new inputdata and push it on the vector
	583	ColladaGeometryInputData *input = new ColladaGeometryInputData();
	584	input->idx = (!idx.empty()) ? static_cast<uint>(atoi(idx.c_str())) : polygon->inputs.size();
	585	input->semantic = tmpsemantic;
	586	input->source = gsource;
	587
	588	// check for duplicate <input>
	589	bool idxrepeat = false;
	590	for (ColladaGeometryInputDataPtrVector::iterator jt = polygon->inputs.begin(); jt != polygon->inputs.end() && !idxrepeat; ++jt)
	591	{
	592	if ((*jt)->idx == input->idx) idxrepeat = true;
	593	}
	594	if (!idxrepeat) polygon->inputs.push_back(input);
	595	else OGRE_DELETE(input); // free unneeded geometry input data
	596	}
	597	// unknwon or unsupported
	598	else
	599	{
	600	LogManager::getSingleton().logMessage("ColladaGeometry::importPolygonsNode - unknown <semantic> " + semantic + " in <geometry> " + mId);
	601	continue;
	602	}
	603	}
	604	// <p> first appearance, break, cause we will parse the primitves later
	605	else if (tagname == CS_ELM_P) break;
	606	// unknwon or unsupported
	607	else
	608	{
	609	LogManager::getSingleton().logMessage("ColladaGeometry::importPolygonsNodes - unknown child: " + tagname);
	610	continue;
	611	}
	612	}
	613
	614	// there should be at least one <input> with semantic="VERTEX"
	615	if (polygon->inputs.at(0)->semantic != ColladaGeometrySpecific::VERTEX) continue;
	616	polygon->inputCount = static_cast<uint>(polygon->inputs.size());
	617
	618	uint indexCount = 0;
	619	polygon->vertexCount = 0;
	620	uint tmppCount = 0;
	621
	622	// parse primitives, <p> nodes, line by line
	623	for (; c != NULL; c = c->next)
	624	{
	625	if (c->type != XML_ELEMENT_NODE) continue;
	626
	627	// get all indices (vertices, normals, texcoords)
	628	// ATTENTION: holes <h/> are currently not supported !!
	629	String primitive = ColladaUtils::getContentDirect(c);
	630
	631	// split the primitive string
	632	StringVector sallindices = StringUtil::split(primitive," ");
	633	if (sallindices.empty()) continue;
	634
	635	// get the amount of vertex indices of one polygon, quad patches are pleasant
	636	indexCount = static_cast<uint>(sallindices.size()) / polygon->inputCount;
	637	if (indexCount != polygon->vertexCount)
	638	{
	639	// skip the false primitive line, but be aware of false geometries (e.g. holes)!
	640	// perhaps it is better to stop reading immediately?
	641	if (polygon->vertexCount > 0)
	642	{
	643	LogManager::getSingleton().logMessage("ColladaGeometry::importPolygonsNodes - different index count? " + mId);
	644	LogManager::getSingleton().logMessage("ColladaGeometry::importPolygonsNodes - primitive: " + primitive);
	645	continue;
	646	}
	647	polygon->vertexCount = indexCount;
	648	}
	649
	650	// we can parse more than quad patches
	651	// but should we do this? currently there is only a simple algortihm which triangulate
	652	if (polygon->vertexCount > 4)
	653	{
	654	LogManager::getSingleton().logMessage("ColladaGeometry::importPolygonsNodes - why are you not using quad patches?");
	655	}
	656
	657	intVector iallindices;
	658	iallindices.reserve(sallindices.size());
	659
	660	// fill up a temp indices vector with conversions to int
	661	for (StringVector::iterator st = sallindices.begin(); st != sallindices.end(); ++st)
	662	{
	663	iallindices.push_back(atoi((*st).c_str()));
	664	}
	665
	666	// fill up the corresponding index vectors with indices
	667	for (uint offset = 0; offset < static_cast<uint>(iallindices.size()); offset += polygon->inputCount)
	668	{
	669	// in order of inputs
	670	for (ColladaGeometryInputDataPtrVector::iterator pt = polygon->inputs.begin(); pt != polygon->inputs.end(); ++pt)
	671	{
	672	(pt)->indices.push_back(iallindices[offset + (pt)->idx]);
	673	}
	674	}
	675
	676	tmppCount++;
	677	}
	678
	679	// if there was a failure in parsing primitives, the amount is not still the same
	680	if (tmppCount < polygon->primitiveCount) polygon->primitiveCount = tmppCount;
	681
	682	mPolygons.push_back(polygon);
	683	}
	684
	685	return true;
	686	}
	687
	688	//-------------------------------------------------------------------------
	689	ColladaGeometrySource ColladaGeometry::importSourceNode(xmlNode sourceNode)
	690	{
	691	if (sourceNode == NULL) return NULL;
	692
	693	// get unique identifier
	694	String id = ColladaUtils::getProperty(sourceNode, CS_ATR_ID);
	695
	696	// check if source is already loaded
	697	for (ColladaGeometrySourcePtrVector::iterator itsource = mSources.begin(); itsource != mSources.end(); ++itsource)
	698	{
	699	if ((itsource)->id == id) return itsource;
	700	}
	701
	702	// get all <technique> child nodes
	703	xmlNodePtrVector techniques = ColladaUtils::getChildsByTagName(sourceNode, CS_ELM_TECHNIQUE);
	704
	705	// currently we are only interested in "COMMON" profile
	706	xmlNode *technique = NULL;
	707	for (xmlNodePtrVector::iterator it = techniques.begin(); it != techniques.end(); ++it)
	708	{
	709	String profile = ColladaUtils::getProperty(*it, CS_ATR_PROFILE);
	710	if (profile == CS_VAL_TECHNIQUE_PROFILE_COMMON)
	711	{
	712	technique = *it;
	713	break;
	714	}
	715	}
	716	if (technique == NULL) return NULL;
	717
	718	// currently ignore <asset>, <param>
	719	// get <accessor> information
	720	xmlNode *accessor = ColladaUtils::getChildByTagName(technique, CS_ELM_ACCESSOR);
	721	if (accessor == NULL) return NULL;
	722	// currently ignore <combiner>, <joints>, <program>
	723
	724	// get count and stride properties
	725	String count = ColladaUtils::getProperty(accessor, CS_ATR_COUNT);
	726	String stride = ColladaUtils::getProperty(accessor, CS_ATR_ACCESSOR_STRIDE);
	727
	728	// new source record
	729	ColladaGeometrySource *source = new ColladaGeometrySource();
	730	source->id = id;
	731	source->count = (!count.empty()) ? static_cast<uint>(atoi(count.c_str())) : 0;
	732	source->stride = (!stride.empty()) ? static_cast<uint>(atoi(stride.c_str())) : 0;
	733
	734	// get data from <float_array>
	735	xmlNode *data = ColladaUtils::getChildByTagName(sourceNode, CS_ELM_FLOAT_ARRAY);
	736	if (data == NULL) return NULL;
	737
	738	String content = ColladaUtils::getContentDirect(data);
	739	if (content.empty()) return NULL;
	740
	741	// split string data by carriage return and line feed
	742	StringVector lines = StringUtil::split(content,"\r\n");
	743	if (lines.size() != source->count) source->count = static_cast<uint>(lines.size());
	744	// reserve enough space
	745	source->data.reserve(source->count * source->stride);
	746	// walk through each data per line
	747	for (StringVector::iterator jt = lines.begin(); jt != lines.end(); ++jt)
	748	{
	749	// split each line by a blank
	750	StringVector line = StringUtil::split(*jt," ");
	751	// for vertices (x, y, z), normals (x, y, z), texcoord (s, t), ...
	752	for (StringVector::iterator kt = line.begin(); kt != line.end(); ++kt)
	753	{
	754	source->data.push_back( StringConverter::parseReal(*kt) );
	755	}
	756	}
	757
	758	mSources.push_back(source);
	759
	760	return source;
	761	}
	762
	763	//-------------------------------------------------------------------------
	764	bool ColladaGeometry::importVerticesNode(xmlNode *meshNode)
	765	{
	766	// get <vertices ...> node of mesh
	767	xmlNode *vertices = ColladaUtils::getChildByTagName(meshNode, CS_ELM_VERTICES);
	768	if (vertices == NULL)
	769	{
	770	LogManager::getSingleton().logMessage("ColladaGeometry::importVerticesNode - no <vertices> node found in <geometry> " + mId);
	771	return false;
	772	}
	773
	774	// walk through <input> childs
	775	for (xmlNode *c = vertices->children; c != NULL; c = c->next)
	776	{
	777	if (c->type != XML_ELEMENT_NODE) continue;
	778
	779	String tagname = (const char *)c->name;
	780	// <input>
	781	if (tagname == CS_ELM_INPUT)
	782	{
	783	// get semantic attribute type
	784	String semantic = ColladaUtils::getProperty(c, CS_ATR_INPUT_SEMANTIC);
	785	ColladaGeometrySpecific::Semantic tmpsemantic = ColladaGeometrySpecific::getSemantic(semantic);
	786
	787	if (tmpsemantic == ColladaGeometrySpecific::POSITION \|\|
	788	tmpsemantic == ColladaGeometrySpecific::NORMAL \|\|
	789	tmpsemantic == ColladaGeometrySpecific::COLOR \|\|
	790	tmpsemantic == ColladaGeometrySpecific::TEXCOORD)
	791	{
	792	// if (tmpsemantic == ColladaGeometryInput::NORMAL) mhasNormals = true;
	793	// if (tmpsemantic == ColladaGeometryInput::TEXCOORD) mhasTexCoords = true;
	794
	795	// get source string
	796	String source = ColladaUtils::getProperty(c, CS_ATR_INPUT_SOURCE);
	797	if (source.empty()) continue;
	798
	799	// import source
	800	ColladaGeometrySource *gsource = importSourceNode(ColladaUtils::getChildById(meshNode, source.c_str()));
	801	if (gsource == NULL)
	802	{
	803	LogManager::getSingleton().logMessage("ColladaGeometry::importVerticesNode - unable to find/import <source> with id " + source);
	804	continue;
	805	}
	806
	807	// make new inputdata and push it on the vector
	808	ColladaGeometryInputData *idata = new ColladaGeometryInputData();
	809	idata->semantic = tmpsemantic;
	810	idata->source = gsource;
	811
	812	mVertexInputs.push_back(idata);
	813	}
	814	// unknown or unsupported
	815	else
	816	{
	817	LogManager::getSingleton().logMessage("ColladaGeometry::importVerticesNode - unknown <semantic> " + semantic + " in <geometry> " + mId);
	818	continue;
	819	}
	820	}
	821	// unknown or unsupported
	822	else
	823	{
	824	LogManager::getSingleton().logMessage("ColladaGeometry::importVerticesNode - unknown child: " + tagname);
	825	}
	826	}
	827
	828	// there must be at least one <input semantic="POSITION" ...>
	829	return (mVertexInputs.at(0)->semantic == ColladaGeometrySpecific::POSITION);
	830	}
	831
	832	//----------------------------------------------------------------------------
	833	void ColladaGeometry::printIndices(void)
	834	{
	835	LogManager::getSingleton().logMessage(StringConverter::toString(mOgreMesh->indices.size()));
	836	for (ColladaGeometryOgreMeshIndexData::iterator it = mOgreMesh->indices.begin(); it != mOgreMesh->indices.end(); ++it)
	837	{
	838	String result = "";
	839	for (uint i = 0; i < (*it)->count; i++)
	840	{
	841	if (i % 3 == 0) result += "\n";
	842	result += " " + StringConverter::toString((*it)->indices[i]);
	843	}
	844	LogManager::getSingleton().logMessage(result + " " + StringConverter::toString((it)->count) + " " + (it)->material);
	845	}
	846	}
	847
	848	//----------------------------------------------------------------------------
	849	void ColladaGeometry::printVertices(const unsigned short x)
	850	{
	851	String result = "";
	852	LogManager::getSingleton().logMessage(StringConverter::toString(mOgreMesh->vertexCount));
	853	for (uint i = 0; i < mOgreMesh->vertexCount * x; i++)
	854	{
	855	if (i % x == 0) result += "\n";
	856	result += " " + StringConverter::toString(mOgreMesh->vertices[i]);
	857	}
	858	LogManager::getSingleton().logMessage(result);
	859	}
	860
	861	//----------------------------------------------------------------------------
	862	void ColladaGeometry::setBoundingBox(ColladaBoundingBox *b)
	863	{
	864	if (mBB == NULL) return;
	865
	866	mBB = b;
	867	mBBReset = true;
	868	}
	869
	870	//----------------------------------------------------------------------------
	871	namespace ColladaGeometrySpecific
	872	{
	873	Semantic getSemantic(const String &s)
	874	{
	875	if (s == CS_VAL_INPUT_SEMANTIC_POSITION) return POSITION;
	876	else if (s == CS_VAL_INPUT_SEMANTIC_VERTEX) return VERTEX;
	877	else if (s == CS_VAL_INPUT_SEMANTIC_NORMAL) return NORMAL;
	878	else if (s == CS_VAL_INPUT_SEMANTIC_TEXCOORD) return TEXCOORD;
	879	else if (s == CS_VAL_INPUT_SEMANTIC_COLOR) return COLOR;
	880	else return UNKNOWN;
	881	}
	882	}
	883	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: