Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

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

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

Line
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: