Salve a tutti.
Ho un pezzo di codice che non mi convince per niente.
Ho scritto una funzione che, da un array di floats contenente un VertexBuffer, rimuove tutti i duplicati e genera un IndexBuffer adeguato.

Per chi non lo sapesse, il VertexBuffer è un array di float che contiene informazioni sui vertici di una geometria (Posizione, Normali, Coordinate di Texture) e l'indexBuffer un arrai di indici.

Ora io ho un array di float con diversi vertici, tra i quali ci sono duplicati. Per diminuire il consumo di memoria, si usa creare un index buffer: ossia eliminare tutti i duplicati dal vertex buffer e segnare sull'indexbuffer la posizione dei vertici.
Così, invece di avere un quadrato formato da 6 vertici

A-B-C & A-C-D

Basterà avere un vertex buffer
ABCD e un Indexbuffer
0-1-2-0-2-3

Ho scritto questa funzione,che richiede però oltre 18 secondi, un tempo inammissibile, mentre di solito l'operazione viene effettuata a runtime in un paio di secondi.

codice:
		std::vector<float> OrigVertices;
		std::vector<float> NewVertices;

	std::vector<unsigned int> OptIndices;

	for (UINT i = 0; i < this->ColladaBuffer.Indici;i++)
	{
		Indices[i] = i;
	}

	OptIndices.insert(OptIndices.begin(),Indices,Indices + this->ColladaBuffer.Indici);
	OrigVertices.insert(OrigVertices.begin(),buffer,buffer + bufsize);
	NewVertices.insert(NewVertices.begin(),OrigVertices.begin(),OrigVertices.begin() + 9);


	{
		D3DVECTOR Vx,Nx,Tx;
		D3DVECTOR VxN,NxN,TxN;

		int OrigVertIdx, NewVertIdx;

		bool DuplicateV;

		for (int i = 9; i < (OrigVertices.size());i += 9)
		{
			OrigVertIdx = i/9;

			Vx.x = OrigVertices[i];
			Vx.y = OrigVertices[i+1];
			Vx.z = OrigVertices[i+2];
			Nx.x = OrigVertices[i+3];
			Nx.y = OrigVertices[i+4];
			Nx.z = OrigVertices[i+5];
			Tx.x = OrigVertices[i+6];
			Tx.y = OrigVertices[i+7];
			Tx.z = OrigVertices[i+8];

			DuplicateV = false;

			for (int j = 0; j < (NewVertices.size());j +=9 )
			{
				VxN.x = NewVertices[j];
				VxN.y = NewVertices[j+1];
				VxN.z = NewVertices[j+2];
				NxN.x = NewVertices[j+3];
				NxN.y = NewVertices[j+4];
				NxN.z = NewVertices[j+5];
				TxN.x = NewVertices[j+6];
				TxN.y = NewVertices[j+7];
				TxN.z = NewVertices[j+8];

				if (fabs(Vx.x-VxN.x) < Epsilon && fabs(Vx.y-VxN.y) < Epsilon && fabs(Vx.z-VxN.z) < Epsilon)
				{
					NewVertIdx = j/9;
					OptIndices[OrigVertIdx] = NewVertIdx;
					DuplicateV = true;

					break;
				}
			}

			if (!DuplicateV)
			{
				NewVertIdx = (NewVertices.size())/9;
				NewVertices.push_back(Vx.x);
				NewVertices.push_back(Vx.y);
				NewVertices.push_back(Vx.z);
				NewVertices.push_back(Nx.x);
				NewVertices.push_back(Nx.y);
				NewVertices.push_back(Nx.z);
				NewVertices.push_back(Tx.x);
				NewVertices.push_back(Tx.y);
				NewVertices.push_back(Tx.z);
				OptIndices[OrigVertIdx] = NewVertIdx ;
			}
		}
	}
Sapreste come ottimizzarla in modo estremo?