spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

void CPartlist::ExportToFile(LPCSTR Filename)
{

    char acDateiname[32];
    FILE* Datei=NULL;
    FileChunk ChunkHeader;
    DWORD dwChunkSizeTest=0;

    sprintf(acDateiname, "%s.mdl", Filename);

    Datei=fopen(acDateiname, "w");
    if(NULL==Datei) Error("Fehler beim erstellen der Exportdatei!");
    
    //Den DateiHeader schreiben
    ChunkHeader.eChunkTyp=CT_HEADER1;
    ChunkHeader.dwChunkSize=sizeof(int);
    fwrite(&ChunkHeader, sizeof(FileChunk), 1, Datei);
    int iDateiTyp=2;//Modelleditordatei, exportiert
    fwrite(&iDateiTyp, sizeof(int), 1, Datei);


    //Als erstes die Gesamtzahl der Vertices/Indices ermitteln
    int iNumVertices=0;
    int iNumIndices=0;
    m_PartIt=m_Partliste.begin();
    for(int i=0; i<m_Partliste.size(); i++)//Schleife durchgehen und Teilzahlen zu Gesamtzahl addieren
    {
        iNumVertices+=(*m_PartIt)->GetNumVertices();
        iNumIndices+=(*m_PartIt)->GetNumIndices();
        m_PartIt++;
    }


    //Die Vertices schreiben:
    ChunkHeader.eChunkTyp=CT_VERTICES;
    ChunkHeader.dwChunkSize=sizeof(int)+sizeof(DWORD)+(sizeof(TexturedVertex)*iNumVertices);
    fwrite(&ChunkHeader, sizeof(FileChunk), 1, Datei);
    dwChunkSizeTest=0;
    DWORD dwFVF=TexturedVertexFVF;
    dwChunkSizeTest+=fwrite(&iNumVertices, sizeof(int), 1, Datei)*sizeof(int);//Anzahl der Vertices
    dwChunkSizeTest+=fwrite(&dwFVF, sizeof(DWORD), 1, Datei)*sizeof(DWORD);//Das Format
    m_PartIt=m_Partliste.begin();//Schleife zum speichern aller Parts
    for(i=0; i<m_Partliste.size(); i++)
    {
        dwChunkSizeTest+=fwrite((*m_PartIt)->GetVertices(), sizeof(TexturedVertex), (*m_PartIt)->GetNumVertices(), Datei)*sizeof(TexturedVertex);
        m_PartIt++;
    }
    if(dwChunkSizeTest!=ChunkHeader.dwChunkSize)
    {
        Error("Export: Fehler beim berechnen der Chunkgröße! CT_VERTICES");
        Error(dwChunkSizeTest);
        Error(ChunkHeader.dwChunkSize);
    }


    //Die Indices schreiben
    ChunkHeader.eChunkTyp=CT_INDICES;
    ChunkHeader.dwChunkSize=sizeof(int)+sizeof(DWORD)+(sizeof(IndexFormat)*iNumIndices);
    fwrite(&ChunkHeader, sizeof(FileChunk), 1, Datei);
    dwChunkSizeTest=0;
    IndexFormat offset=0;  // Offset für die Index-Werte 
    DWORD dwIF=sizeof(IndexFormat);
    dwChunkSizeTest+=fwrite(&iNumIndices, sizeof(int), 1, Datei)*sizeof(int);//Anzahl der Indices
    dwChunkSizeTest+=fwrite(&dwIF, sizeof(DWORD), 1, Datei)*sizeof(DWORD);//IndexFormat schreiben
    m_PartIt = m_Partliste.begin();
    for(i=0; i<m_Partliste.size(); i++) 
    {
        for(int c=0; c<(*m_PartIt)->GetNumIndices(); c++)
        {
            IndexFormat Index = (*m_PartIt)->GetIndices()[c] + offset; 
            dwChunkSizeTest+=fwrite(&Index, sizeof(IndexFormat), 1, Datei)*sizeof(IndexFormat); 
        }
        offset+=(IndexFormat)(*m_PartIt)->GetNumVertices();
        m_PartIt++;
    }
    if(dwChunkSizeTest!=ChunkHeader.dwChunkSize)
    {
        Error("Export: Fehler beim berechnen der Chunkgröße! CT_INDICES");
        Error(dwChunkSizeTest);
        Error(ChunkHeader.dwChunkSize);
    }


    //Die Textur schreiben:
    ChunkHeader.eChunkTyp=CT_TEXTURE;
    ChunkHeader.dwChunkSize=sizeof(char)*16;
    fwrite(&ChunkHeader, sizeof(FileChunk), 1, Datei);
    dwChunkSizeTest=0;
    dwChunkSizeTest+=fwrite(m_acTexturename, sizeof(char), 16, Datei)*sizeof(char);
    if(dwChunkSizeTest!=ChunkHeader.dwChunkSize)
    {
        Error("Export: Fehler beim berechnen der Chunkgröße! CT_TEXTURE");
        Error(dwChunkSizeTest);
        Error(ChunkHeader.dwChunkSize);
    }

    
    //Die Gruppeninformationen schreiben, damit die Datei später wieder ins Editorformat umgewandelt werden kann!
    ChunkHeader.eChunkTyp=CT_PARTINFOS;
    ChunkHeader.dwChunkSize=sizeof(int)+(sizeof(int)*2*m_Partliste.size());//Anzahl der Gruppen, für jede Gruppe Anzahl Vertices, Anzahl Indices
    fwrite(&ChunkHeader, sizeof(FileChunk), 1, Datei);
    dwChunkSizeTest=0;
    int iNumParts=m_Partliste.size();
    dwChunkSizeTest+=fwrite(&iNumParts, sizeof(int), 1, Datei)*sizeof(int);//Anzahl der Gruppen
    m_PartIt=m_Partliste.begin();
    for(i=0; i<m_Partliste.size(); i++)
    {
        int iPuffer=0;
        iPuffer=(*m_PartIt)->GetNumVertices();//Für Jede Gruppen Anzahl Vertices und Indices speichern
        dwChunkSizeTest+=fwrite(&iPuffer, sizeof(int), 1, Datei)*sizeof(int);
        iPuffer=(*m_PartIt)->GetNumIndices();
        dwChunkSizeTest+=fwrite(&iPuffer, sizeof(int), 1, Datei)*sizeof(int);
    }
    if(dwChunkSizeTest!=ChunkHeader.dwChunkSize)
    {
        Error("Export: Fehler beim berechnen der Chunkgröße! CT_PARTINFOS");
        Error(dwChunkSizeTest);
        Error(ChunkHeader.dwChunkSize);
    }



    //uff endlich alles gespeichert! Datei schließen:
    fclose(Datei);
}