tools/a3dconvert/ColladaGeometry.cpp - platform/development - Git at Google

 /*
 * Copyright 2006 Sony Computer Entertainment Inc.
 *
 * Licensed under the MIT Open Source License, for details please see license.txt or the website
 * http://www.opensource.org/licenses/mit-license.php
 *
 */

 #include "ColladaGeometry.h"
 #include <iostream>
 #include <sstream>

 ColladaGeometry::ColladaGeometry() :
         mPositionFloats(NULL), mPositionOffset(-1),
         mNormalFloats(NULL), mNormalOffset(-1),
         mTangentFloats(NULL), mTangentOffset(-1),
         mBinormalFloats(NULL), mBinormalOffset(-1),
         mTexture1Floats(NULL), mTexture1Offset(-1),
         mMultiIndexOffset(-1),
         mPositionsStride(3), mNormalsStride(3),
         mTextureCoordsStride(2), mTangentssStride(3), mBinormalsStride(3) {

     mConvertedMesh.appendChannel("position", mPositionsStride);
     mConvertedMesh.appendChannel("normal", mNormalsStride);
     mConvertedMesh.appendChannel("texture0", mTextureCoordsStride);
     mConvertedMesh.appendChannel("binormal", mBinormalsStride);
     mConvertedMesh.appendChannel("tangent", mTangentssStride);

     mPositions = &mConvertedMesh.mChannels[0].mData;
     mNormals = &mConvertedMesh.mChannels[1].mData;
     mTextureCoords = &mConvertedMesh.mChannels[2].mData;
     mBinormals = &mConvertedMesh.mChannels[3].mData;
     mTangents = &mConvertedMesh.mChannels[4].mData;
 }

 bool ColladaGeometry::init(domGeometryRef geometry) {

     bool convertSuceeded = true;

     const char* geoName = geometry->getName();
     if (geoName == NULL) {
         geoName = geometry->getId();
     }
     mConvertedMesh.mName = geoName;
     mMesh = geometry->getMesh();

     // Iterate over all the index groups and build up a simple resolved tri list and vertex array
     const domTriangles_Array &allTriLists = mMesh->getTriangles_array();
     int numTriLists = allTriLists.getCount();
     mConvertedMesh.mTriangleLists.reserve(numTriLists);
     mConvertedMesh.mTriangleListNames.reserve(numTriLists);
     for (int i = 0; i < numTriLists; i ++) {
         addTriangles(allTriLists[i]);
     }

     return convertSuceeded;
 }

 void ColladaGeometry::addTriangles(domTriangles * colladaTriangles) {

     int numTriangles = colladaTriangles->getCount();
     int triListIndex = mConvertedMesh.mTriangleLists.size();
     mConvertedMesh.mTriangleLists.resize(triListIndex + 1);
     std::string materialName = colladaTriangles->getMaterial();
     if (materialName.size() == 0) {
         char buffer[128];
         sprintf(buffer, "index%d", triListIndex);
         materialName = buffer;
     }
     mConvertedMesh.mTriangleListNames.push_back(materialName);

     // It's a good idea to tell stl how much memory we intend to use
     // to limit the number of reallocations
     mPositions->reserve(numTriangles * 3);
     mNormals->reserve(numTriangles * 3);
     mTangents->reserve(numTriangles * 3);
     mBinormals->reserve(numTriangles * 3);
     mTextureCoords->reserve(numTriangles * 3);

     // Stores the pointers to the image data and where in the tri list that data comes from
     cacheOffsetsAndDataPointers(colladaTriangles);

     // Collapse the multiindex that collada uses
     const domListOfUInts &colladaIndexList = colladaTriangles->getP()->getValue();
     std::vector<uint32_t> &a3dIndexList = mConvertedMesh.mTriangleLists[triListIndex];
     a3dIndexList.resize(numTriangles * 3);
     for (int i = 0; i < numTriangles * 3; i ++) {

         a3dIndexList[i] = remapIndexAndStoreData(colladaIndexList, i);
     }

 }

 void ColladaGeometry::cacheOffsetsAndDataPointers(domTriangles * colladaTriangles) {
     // Define the names of known vertex channels
     const char *positionSemantic = "POSITION";
     const char *vertexSemantic = "VERTEX";
     const char *normalSemantic = "NORMAL";
     const char *tangentSemantic = "TANGENT";
     const char *binormalSemantic = "BINORMAL";
     const char *texture1Semantic = "TEXCOORD";

     const domInputLocalOffset_Array &inputs = colladaTriangles->getInput_array();
     mMultiIndexOffset = inputs.getCount();

     // inputs with offsets
     // There are two places collada can put links to our data
     // 1 - in the VERTEX, which is its way of saying follow a link to the vertex structure
     //     then every geometry array you find there is the same size as the position array
     // 2 - a direct link to the channel from the primitive list. This tells us that there are
     //     potentially more or less floats in those channels because there is some vertex re-use
     //     or divergence in that data channel. For example, highly segmented uv set would produce a
     //     larger array because for every physical vertex position thre might be 2 or more uv coords
     for (uint32_t i = 0; i < inputs.getCount(); i ++) {

         int currentOffset = inputs[i]->getOffset();
         const char *currentSemantic = inputs[i]->getSemantic();

         domSource * source = (domSource*) (domElement*) inputs[i]->getSource().getElement();
         if (strcmp(vertexSemantic, currentSemantic) == 0) {
             mPositionOffset = currentOffset;
         }
         else if (strcmp(normalSemantic, currentSemantic) == 0) {
             mNormalOffset = currentOffset;
             mNormalFloats = &source->getFloat_array()->getValue();
         }
         else if (strcmp(tangentSemantic, currentSemantic) == 0) {
             mTangentOffset = currentOffset;
             mTangentFloats = &source->getFloat_array()->getValue();
         }
         else if (strcmp(binormalSemantic, currentSemantic) == 0) {
             mBinormalOffset = currentOffset;
             mBinormalFloats = &source->getFloat_array()->getValue();
         }
         else if (strcmp(texture1Semantic, currentSemantic) == 0) {
             mTexture1Offset = currentOffset;
             mTexture1Floats = & source->getFloat_array()->getValue();
         }
     }

     // There are multiple ways of getting to data, so follow them all
     domVertices * vertices = mMesh->getVertices();
     const domInputLocal_Array &verticesInputs = vertices->getInput_array();
     for (uint32_t i = 0; i < verticesInputs.getCount(); i ++) {

         const char *currentSemantic = verticesInputs[i]->getSemantic();

         domSource * source = (domSource*) (domElement*) verticesInputs[i]->getSource().getElement();
         if (strcmp(positionSemantic, currentSemantic) == 0) {
             mPositionFloats = & source->getFloat_array()->getValue();
             // TODO: Querry this from the accessor in the future because
             // I supopose it's possible to have 4 floats if we hide something in w
             int numberOfFloatsPerPoint = 3;
             // We want to cllapse duplicate vertices, otherwise we could just unroll the tri list
             mVertexRemap.resize(source->getFloat_array()->getCount()/numberOfFloatsPerPoint);
         }
         else if (strcmp(normalSemantic, currentSemantic) == 0) {
             mNormalFloats = & source->getFloat_array()->getValue();
             mNormalOffset = mPositionOffset;
         }
         else if (strcmp(tangentSemantic, currentSemantic) == 0) {
             mTangentFloats = & source->getFloat_array()->getValue();
             mTangentOffset = mPositionOffset;
         }
         else if (strcmp(binormalSemantic, currentSemantic) == 0) {
             mBinormalFloats = & source->getFloat_array()->getValue();
             mBinormalOffset = mPositionOffset;
         }
         else if (strcmp(texture1Semantic, currentSemantic) == 0) {
             mTexture1Floats = & source->getFloat_array()->getValue();
             mTexture1Offset = mPositionOffset;
         }
     }
 }

 int ColladaGeometry::remapIndexAndStoreData(const domListOfUInts &colladaIndexList, int indexToRemap) {

     domUint positionIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mPositionOffset];

     float posX = (*mPositionFloats)[positionIndex * mPositionsStride + 0];
     float posY = (*mPositionFloats)[positionIndex * mPositionsStride + 1];
     float posZ = (*mPositionFloats)[positionIndex * mPositionsStride + 2];

     float normX = 0;
     float normY = 0;
     float normZ = 0;

     if (mNormalOffset != -1) {
         domUint normalIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mNormalOffset];
         normX = (*mNormalFloats)[normalIndex * mNormalsStride + 0];
         normY = (*mNormalFloats)[normalIndex * mNormalsStride + 1];
         normZ = (*mNormalFloats)[normalIndex * mNormalsStride + 2];
     }

     float tanX = 0;
     float tanY = 0;
     float tanZ = 0;

     if (mTangentOffset != -1) {
         domUint tangentIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mTangentOffset];
         tanX = (*mTangentFloats)[tangentIndex * mTangentssStride + 0];
         tanY = (*mTangentFloats)[tangentIndex * mTangentssStride + 1];
         tanZ = (*mTangentFloats)[tangentIndex * mTangentssStride + 2];
     }

     float binormX = 0;
     float binormY = 0;
     float binormZ = 0;

     if (mBinormalOffset != -1) {
         domUint binormalIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mNormalOffset];
         binormX = (*mBinormalFloats)[binormalIndex * mBinormalsStride + 0];
         binormY = (*mBinormalFloats)[binormalIndex * mBinormalsStride + 1];
         binormZ = (*mBinormalFloats)[binormalIndex * mBinormalsStride + 2];
     }

     float texCoordX = 0;
     float texCoordY = 0;

     if (mTexture1Offset != -1) {
         domUint texCoordIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mTexture1Offset];
         texCoordX = (*mTexture1Floats)[texCoordIndex * mTextureCoordsStride + 0];
         texCoordY = (*mTexture1Floats)[texCoordIndex * mTextureCoordsStride + 1];
     }

     std::vector<uint32_t> &ithRemapList = mVertexRemap[positionIndex];
     // We may have some potential vertices we can reuse
     // loop over all the potential candidates and see if any match our guy
     for (uint32_t i = 0; i < ithRemapList.size(); i ++) {

         int ithRemap = ithRemapList[i];
         // compare existing vertex with the new one
         if ((*mPositions)[ithRemap * mPositionsStride + 0] != posX ||
             (*mPositions)[ithRemap * mPositionsStride + 1] != posY ||
             (*mPositions)[ithRemap * mPositionsStride + 2] != posZ) {
             continue;
         }

         // Now go over normals
         if (mNormalOffset != -1) {
             if ((*mNormals)[ithRemap * mNormalsStride + 0] != normX ||
                 (*mNormals)[ithRemap * mNormalsStride + 1] != normY ||
                 (*mNormals)[ithRemap * mNormalsStride + 2] != normZ) {
                 continue;
             }
         }

         // Now go over tangents
         if (mTangentOffset != -1) {
             if ((*mTangents)[ithRemap * mTangentssStride + 0] != tanX ||
                 (*mTangents)[ithRemap * mTangentssStride + 1] != tanY ||
                 (*mTangents)[ithRemap * mTangentssStride + 2] != tanZ) {
                 continue;
             }
         }

         // Now go over binormals
         if (mBinormalOffset != -1) {
             if ((*mBinormals)[ithRemap * mBinormalsStride + 0] != binormX ||
                 (*mBinormals)[ithRemap * mBinormalsStride + 1] != binormY ||
                 (*mBinormals)[ithRemap * mBinormalsStride + 2] != binormZ) {
                 continue;
             }
         }

         // And texcoords
         if (mTexture1Offset != -1) {
             if ((*mTextureCoords)[ithRemap * mTextureCoordsStride + 0] != texCoordX ||
                 (*mTextureCoords)[ithRemap * mTextureCoordsStride + 1] != texCoordY) {
                continue;
             }
         }

         // If we got here the new vertex is identical to the one that we already stored
         return ithRemap;
     }

     // We did not encounter this vertex yet, store it and return its index
     mPositions->push_back(posX);
     mPositions->push_back(posY);
     mPositions->push_back(posZ);

     if (mNormalOffset != -1) {
         mNormals->push_back(normX);
         mNormals->push_back(normY);
         mNormals->push_back(normZ);
     }

     if (mTangentOffset != -1) {
         mTangents->push_back(tanX);
         mTangents->push_back(tanY);
         mTangents->push_back(tanZ);
     }

     if (mBinormalOffset != -1) {
         mBinormals->push_back(binormX);
         mBinormals->push_back(binormY);
         mBinormals->push_back(binormZ);
     }

     if (mTexture1Offset != -1) {
         mTextureCoords->push_back(texCoordX);
         mTextureCoords->push_back(texCoordY);
     }

     // We need to remember this mapping. Since we are storing floats, not vec3's, need to
     // divide by position size to get the right index
     int currentVertexIndex = (mPositions->size()/mPositionsStride) - 1;
     ithRemapList.push_back(currentVertexIndex);

     return currentVertexIndex;
 }
	/*
	* Copyright 2006 Sony Computer Entertainment Inc.
	*
	* Licensed under the MIT Open Source License, for details please see license.txt or the website
	* http://www.opensource.org/licenses/mit-license.php
	*
	*/

	#include "ColladaGeometry.h"
	#include <iostream>
	#include <sstream>

	ColladaGeometry::ColladaGeometry() :
	mPositionFloats(NULL), mPositionOffset(-1),
	mNormalFloats(NULL), mNormalOffset(-1),
	mTangentFloats(NULL), mTangentOffset(-1),
	mBinormalFloats(NULL), mBinormalOffset(-1),
	mTexture1Floats(NULL), mTexture1Offset(-1),
	mMultiIndexOffset(-1),
	mPositionsStride(3), mNormalsStride(3),
	mTextureCoordsStride(2), mTangentssStride(3), mBinormalsStride(3) {

	mConvertedMesh.appendChannel("position", mPositionsStride);
	mConvertedMesh.appendChannel("normal", mNormalsStride);
	mConvertedMesh.appendChannel("texture0", mTextureCoordsStride);
	mConvertedMesh.appendChannel("binormal", mBinormalsStride);
	mConvertedMesh.appendChannel("tangent", mTangentssStride);

	mPositions = &mConvertedMesh.mChannels[0].mData;
	mNormals = &mConvertedMesh.mChannels[1].mData;
	mTextureCoords = &mConvertedMesh.mChannels[2].mData;
	mBinormals = &mConvertedMesh.mChannels[3].mData;
	mTangents = &mConvertedMesh.mChannels[4].mData;
	}

	bool ColladaGeometry::init(domGeometryRef geometry) {

	bool convertSuceeded = true;

	const char* geoName = geometry->getName();
	if (geoName == NULL) {
	geoName = geometry->getId();
	}
	mConvertedMesh.mName = geoName;
	mMesh = geometry->getMesh();

	// Iterate over all the index groups and build up a simple resolved tri list and vertex array
	const domTriangles_Array &allTriLists = mMesh->getTriangles_array();
	int numTriLists = allTriLists.getCount();
	mConvertedMesh.mTriangleLists.reserve(numTriLists);
	mConvertedMesh.mTriangleListNames.reserve(numTriLists);
	for (int i = 0; i < numTriLists; i ++) {
	addTriangles(allTriLists[i]);
	}

	return convertSuceeded;
	}

	void ColladaGeometry::addTriangles(domTriangles * colladaTriangles) {

	int numTriangles = colladaTriangles->getCount();
	int triListIndex = mConvertedMesh.mTriangleLists.size();
	mConvertedMesh.mTriangleLists.resize(triListIndex + 1);
	std::string materialName = colladaTriangles->getMaterial();
	if (materialName.size() == 0) {
	char buffer[128];
	sprintf(buffer, "index%d", triListIndex);
	materialName = buffer;
	}
	mConvertedMesh.mTriangleListNames.push_back(materialName);

	// It's a good idea to tell stl how much memory we intend to use
	// to limit the number of reallocations
	mPositions->reserve(numTriangles * 3);
	mNormals->reserve(numTriangles * 3);
	mTangents->reserve(numTriangles * 3);
	mBinormals->reserve(numTriangles * 3);
	mTextureCoords->reserve(numTriangles * 3);

	// Stores the pointers to the image data and where in the tri list that data comes from
	cacheOffsetsAndDataPointers(colladaTriangles);

	// Collapse the multiindex that collada uses
	const domListOfUInts &colladaIndexList = colladaTriangles->getP()->getValue();
	std::vector<uint32_t> &a3dIndexList = mConvertedMesh.mTriangleLists[triListIndex];
	a3dIndexList.resize(numTriangles * 3);
	for (int i = 0; i < numTriangles * 3; i ++) {

	a3dIndexList[i] = remapIndexAndStoreData(colladaIndexList, i);
	}

	}

	void ColladaGeometry::cacheOffsetsAndDataPointers(domTriangles * colladaTriangles) {
	// Define the names of known vertex channels
	const char *positionSemantic = "POSITION";
	const char *vertexSemantic = "VERTEX";
	const char *normalSemantic = "NORMAL";
	const char *tangentSemantic = "TANGENT";
	const char *binormalSemantic = "BINORMAL";
	const char *texture1Semantic = "TEXCOORD";

	const domInputLocalOffset_Array &inputs = colladaTriangles->getInput_array();
	mMultiIndexOffset = inputs.getCount();

	// inputs with offsets
	// There are two places collada can put links to our data
	// 1 - in the VERTEX, which is its way of saying follow a link to the vertex structure
	// then every geometry array you find there is the same size as the position array
	// 2 - a direct link to the channel from the primitive list. This tells us that there are
	// potentially more or less floats in those channels because there is some vertex re-use
	// or divergence in that data channel. For example, highly segmented uv set would produce a
	// larger array because for every physical vertex position thre might be 2 or more uv coords
	for (uint32_t i = 0; i < inputs.getCount(); i ++) {

	int currentOffset = inputs[i]->getOffset();
	const char *currentSemantic = inputs[i]->getSemantic();

	domSource * source = (domSource) (domElement) inputs[i]->getSource().getElement();
	if (strcmp(vertexSemantic, currentSemantic) == 0) {
	mPositionOffset = currentOffset;
	}
	else if (strcmp(normalSemantic, currentSemantic) == 0) {
	mNormalOffset = currentOffset;
	mNormalFloats = &source->getFloat_array()->getValue();
	}
	else if (strcmp(tangentSemantic, currentSemantic) == 0) {
	mTangentOffset = currentOffset;
	mTangentFloats = &source->getFloat_array()->getValue();
	}
	else if (strcmp(binormalSemantic, currentSemantic) == 0) {
	mBinormalOffset = currentOffset;
	mBinormalFloats = &source->getFloat_array()->getValue();
	}
	else if (strcmp(texture1Semantic, currentSemantic) == 0) {
	mTexture1Offset = currentOffset;
	mTexture1Floats = & source->getFloat_array()->getValue();
	}
	}

	// There are multiple ways of getting to data, so follow them all
	domVertices * vertices = mMesh->getVertices();
	const domInputLocal_Array &verticesInputs = vertices->getInput_array();
	for (uint32_t i = 0; i < verticesInputs.getCount(); i ++) {

	const char *currentSemantic = verticesInputs[i]->getSemantic();

	domSource * source = (domSource) (domElement) verticesInputs[i]->getSource().getElement();
	if (strcmp(positionSemantic, currentSemantic) == 0) {
	mPositionFloats = & source->getFloat_array()->getValue();
	// TODO: Querry this from the accessor in the future because
	// I supopose it's possible to have 4 floats if we hide something in w
	int numberOfFloatsPerPoint = 3;
	// We want to cllapse duplicate vertices, otherwise we could just unroll the tri list
	mVertexRemap.resize(source->getFloat_array()->getCount()/numberOfFloatsPerPoint);
	}
	else if (strcmp(normalSemantic, currentSemantic) == 0) {
	mNormalFloats = & source->getFloat_array()->getValue();
	mNormalOffset = mPositionOffset;
	}
	else if (strcmp(tangentSemantic, currentSemantic) == 0) {
	mTangentFloats = & source->getFloat_array()->getValue();
	mTangentOffset = mPositionOffset;
	}
	else if (strcmp(binormalSemantic, currentSemantic) == 0) {
	mBinormalFloats = & source->getFloat_array()->getValue();
	mBinormalOffset = mPositionOffset;
	}
	else if (strcmp(texture1Semantic, currentSemantic) == 0) {
	mTexture1Floats = & source->getFloat_array()->getValue();
	mTexture1Offset = mPositionOffset;
	}
	}
	}

	int ColladaGeometry::remapIndexAndStoreData(const domListOfUInts &colladaIndexList, int indexToRemap) {

	domUint positionIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mPositionOffset];

	float posX = (mPositionFloats)[positionIndex mPositionsStride + 0];
	float posY = (mPositionFloats)[positionIndex mPositionsStride + 1];
	float posZ = (mPositionFloats)[positionIndex mPositionsStride + 2];

	float normX = 0;
	float normY = 0;
	float normZ = 0;

	if (mNormalOffset != -1) {
	domUint normalIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mNormalOffset];
	normX = (mNormalFloats)[normalIndex mNormalsStride + 0];
	normY = (mNormalFloats)[normalIndex mNormalsStride + 1];
	normZ = (mNormalFloats)[normalIndex mNormalsStride + 2];
	}

	float tanX = 0;
	float tanY = 0;
	float tanZ = 0;

	if (mTangentOffset != -1) {
	domUint tangentIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mTangentOffset];
	tanX = (mTangentFloats)[tangentIndex mTangentssStride + 0];
	tanY = (mTangentFloats)[tangentIndex mTangentssStride + 1];
	tanZ = (mTangentFloats)[tangentIndex mTangentssStride + 2];
	}

	float binormX = 0;
	float binormY = 0;
	float binormZ = 0;

	if (mBinormalOffset != -1) {
	domUint binormalIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mNormalOffset];
	binormX = (mBinormalFloats)[binormalIndex mBinormalsStride + 0];
	binormY = (mBinormalFloats)[binormalIndex mBinormalsStride + 1];
	binormZ = (mBinormalFloats)[binormalIndex mBinormalsStride + 2];
	}

	float texCoordX = 0;
	float texCoordY = 0;

	if (mTexture1Offset != -1) {
	domUint texCoordIndex = colladaIndexList[indexToRemap*mMultiIndexOffset + mTexture1Offset];
	texCoordX = (mTexture1Floats)[texCoordIndex mTextureCoordsStride + 0];
	texCoordY = (mTexture1Floats)[texCoordIndex mTextureCoordsStride + 1];
	}

	std::vector<uint32_t> &ithRemapList = mVertexRemap[positionIndex];
	// We may have some potential vertices we can reuse
	// loop over all the potential candidates and see if any match our guy
	for (uint32_t i = 0; i < ithRemapList.size(); i ++) {

	int ithRemap = ithRemapList[i];
	// compare existing vertex with the new one
	if ((mPositions)[ithRemap mPositionsStride + 0] != posX \|\|
	(mPositions)[ithRemap mPositionsStride + 1] != posY \|\|
	(mPositions)[ithRemap mPositionsStride + 2] != posZ) {
	continue;
	}

	// Now go over normals
	if (mNormalOffset != -1) {
	if ((mNormals)[ithRemap mNormalsStride + 0] != normX \|\|
	(mNormals)[ithRemap mNormalsStride + 1] != normY \|\|
	(mNormals)[ithRemap mNormalsStride + 2] != normZ) {
	continue;
	}
	}

	// Now go over tangents
	if (mTangentOffset != -1) {
	if ((mTangents)[ithRemap mTangentssStride + 0] != tanX \|\|
	(mTangents)[ithRemap mTangentssStride + 1] != tanY \|\|
	(mTangents)[ithRemap mTangentssStride + 2] != tanZ) {
	continue;
	}
	}

	// Now go over binormals
	if (mBinormalOffset != -1) {
	if ((mBinormals)[ithRemap mBinormalsStride + 0] != binormX \|\|
	(mBinormals)[ithRemap mBinormalsStride + 1] != binormY \|\|
	(mBinormals)[ithRemap mBinormalsStride + 2] != binormZ) {
	continue;
	}
	}

	// And texcoords
	if (mTexture1Offset != -1) {
	if ((mTextureCoords)[ithRemap mTextureCoordsStride + 0] != texCoordX \|\|
	(mTextureCoords)[ithRemap mTextureCoordsStride + 1] != texCoordY) {
	continue;
	}
	}

	// If we got here the new vertex is identical to the one that we already stored
	return ithRemap;
	}

	// We did not encounter this vertex yet, store it and return its index
	mPositions->push_back(posX);
	mPositions->push_back(posY);
	mPositions->push_back(posZ);

	if (mNormalOffset != -1) {
	mNormals->push_back(normX);
	mNormals->push_back(normY);
	mNormals->push_back(normZ);
	}

	if (mTangentOffset != -1) {
	mTangents->push_back(tanX);
	mTangents->push_back(tanY);
	mTangents->push_back(tanZ);
	}

	if (mBinormalOffset != -1) {
	mBinormals->push_back(binormX);
	mBinormals->push_back(binormY);
	mBinormals->push_back(binormZ);
	}

	if (mTexture1Offset != -1) {
	mTextureCoords->push_back(texCoordX);
	mTextureCoords->push_back(texCoordY);
	}

	// We need to remember this mapping. Since we are storing floats, not vec3's, need to
	// divide by position size to get the right index
	int currentVertexIndex = (mPositions->size()/mPositionsStride) - 1;
	ithRemapList.push_back(currentVertexIndex);

	return currentVertexIndex;
	}