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?