Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Probleme beim lesen des TBM Formates

Werbeanzeige

koschka

Community-Fossil

  • »koschka« ist der Autor dieses Themas

Beiträge: 2 862

Wohnort: Dresden

Beruf: Student

  • Private Nachricht senden

1

06.05.2005, 21:16

Probleme beim lesen des TBM Formates

Hi,
ich wollte mit einem Programm mal probieren das TBM format zu lesen. Da es gut dokumentiert (Buch) ist und ich auch Q-Text habe (Tribase ;) ). So, es funktioniert auch soweit, er liest korrekt den Chunk Header und den Header des Vertex Daten Chunks. Es scheitert an dem lesen der eigentlichen Vertex Daten, er liest immer zu wenig!

Hier ist erstmal der Code:

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

bool E_CModel::Load(char* pcFilename,            
                    char* pcTexturePrefix,
                    char* pcTexturePostfix, 
                    D3DPOOL VBPool,         // = D3DPOOL_DEFAULT
                    DWORD dwVBUsage,            // = 0
                    D3DPOOL IBPool,             // = D3DPOOL_DEFAULT
                    DWORD dwIBUsage)            // = 0
{
    E_SModelChunkHeader ChunkHeader;
    E_SModelIndicesChunkHeader IndexChunk;
    E_SModelVerticesChunkHeader VertexChunk;

    void* m_pBuffer;
    void* pVertices;
    DWORD dwFirstVertex;
    DWORD dwLastVertex;
    __int64 pos;
    FILE* pFile;

    Exit();

    if(pcFilename == NULL)  return false;

    pFile = fopen(pcFilename, "r");
    if(pFile == NULL)       return false;

    while(!feof(pFile))
    {
        // Chunk Header lesen
        fread(&ChunkHeader, sizeof(E_SModelChunkHeader), 1, pFile);
        
        g_CLog.TextPara("ChunkType: %d", ChunkHeader.ChunkType);
        g_CLog.TextPara("ChunkSize: %d", ChunkHeader.dwDataSize);

        switch(ChunkHeader.ChunkType)
        {
            case E_CT_MODEL_VERTICES:
                g_CLog.Info("VertexDatenChunk wird gelesen...");
                
                fgetpos(pFile, &pos);
                
                g_CLog.Info("POSITION BEFORE VCHUNK READING: %d.", pos);
                fread(&VertexChunk, sizeof(E_SModelVerticesChunkHeader), 1, pFile);
                fgetpos(pFile, &pos);
                
                g_CLog.Info("POSITION AFTER VCHUNK READING: %d.", pos);

                m_dwFVF                 = VertexChunk.dwFVF;
                m_dwNumVertices         = VertexChunk.dwNumVertices;
                m_fBoundingSphereRadius = VertexChunk.fBoundingSphereRadius;
                m_vBoundingBoxMin       = VertexChunk.vBoundingBoxMin;
                m_vBoundingBoxMax       = VertexChunk.vBoundingBoxMax;


                g_CLog.TextPara("NumVertices: %d", m_dwNumVertices);
                g_CLog.TextPara("SizeOf VertexChunk: %d", sizeof(E_SModelVerticesChunkHeader));
                g_CLog.TextPara("VertexSize: %d", VertexChunk.dwVertexSize);
                g_CLog.TextPara("Sizeof all VertexData: %d", VertexChunk.dwVertexSize * m_dwNumVertices);

                // Vertex Buffer erstellen
                if(FAILED(GetD3DDevice()->CreateVertexBuffer(VertexChunk.dwNumVertices * VertexChunk.dwVertexSize,
                                                    dwVBUsage,
                                                    VertexChunk.dwFVF,
                                                    VBPool,
                                                    &m_pVertexBuffer,
                                                    NULL)))
                {
                    g_CLog.Error("Fehler beim Erstellen des Vertex Buffers!");
                    return false;
                }

                dwFirstVertex = 0;
                dwLastVertex = VertexChunk.dwNumVertices - 1;

                m_pBuffer = ::operator new(VertexChunk.dwNumVertices * VertexChunk.dwVertexSize);
                
                fgetpos(pFile, &pos);
                g_CLog.Info("POSITION BEFORE VERTEX READING: %d.", pos);

                // Die Vertex Daten lesen, hier msus ein fehler sein
                fread(m_pBuffer, VertexChunk.dwNumVertices * VertexChunk.dwVertexSize, 1, pFile);
                
                fgetpos(pFile, &pos);
                g_CLog.Info("POSITION AFTER READING: %d.", pos);
                
                g_CLog.TextPara("BufferSize: %d", &m_pBuffer);

                // Den Vertex-Buffer sperren.
                // Die Sperrflags sind 0 bei statischen Vertex-Buffern und
                // D3DLOCK_DISCARD bei dynamischen.
                if(FAILED(m_pVertexBuffer->Lock(0,
                                                (dwLastVertex - dwFirstVertex + 1) * VertexChunk.dwVertexSize,
                                                &pVertices,
                                                (dwVBUsage & D3DUSAGE_DYNAMIC) ? D3DLOCK_DISCARD : 0)))
                {
                    // Fehler beim Sperren!
                    g_CLog.Error("Fehler beim Sperren des Vertex Buffers!");
                    return false;
                }

                // Die Daten in den Puffer kopieren
                memcpy(pVertices, (BYTE*)(m_pBuffer) + dwFirstVertex * VertexChunk.dwVertexSize,
                    (dwLastVertex - dwFirstVertex + 1) * VertexChunk.dwVertexSize);

                // Vertex-Buffer entsperren
                m_pVertexBuffer->Unlock();

                SAFE_DELETE_ARRAY(m_pBuffer);

                g_CLog.Info("VertexDatenChunk fertig gelesen.");

                break;
            case E_CT_MODEL_INDICES:
                g_CLog.Info("IndexDatenChunk");
                break;
            case E_CT_MODEL_EFFECTS:
                g_CLog.Info("EffektDatenChunk");
                break;
            default:
                if(fseek(pFile, ChunkHeader.dwDataSize, SEEK_CUR) != 0)
                {
                    g_CLog.Error("Fehler beim Überspringen eines Chunks");
                    g_CLog.TextPara("%d", ChunkHeader.ChunkType);
                    return false;
                }
                else
                    g_CLog.TextPara("%d", ChunkHeader.ChunkType);
                break;
        }
    }
    fclose(pFile);
    return true;

und hier die Ausgabe:

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11

 ChunkType: 0
ChunkSize: 39752
> INFO VertexDatenChunk wird gelesen...
> INFO POSITION BEFORE VCHUNK READING: 3592.
> INFO POSITION AFTER VCHUNK READING: 3632.
NumVertices: 1241
SizeOf VertexChunk: 40
VertexSize: 32
Sizeof all VertexData: 39712
> INFO POSITION BEFORE VERTEX READING: 3632.
> INFO POSITION AFTER READING: 40960.


Er beginnt beim 3592. Byte, liest dann die 40 Byte (VertexChunkHeader), was ja korrekt ist! Der Chunk ist aber 39752 - 40 = 39712 Byte groß, was jka auch stimmt (siehe Sizeof Vertex Data) (ergibt sich aus VertexSize * NumVertices = 32*1241 = 39712. Also ist auch korrekt.

Aber er liest nur bis Byte 40960. Aber wieso 40960??? Den 40960 - 3592 < ChunkSize. Er sollte doch bis: 3592 + 39712 = 43304 lesen!

Ich weiss nicht arum der weniger liest, sitz schon ewig an den Prob, bitte um Hilfe :)

koschka

Community-Fossil

  • »koschka« ist der Autor dieses Themas

Beiträge: 2 862

Wohnort: Dresden

Beruf: Student

  • Private Nachricht senden

2

07.05.2005, 18:42

oh yipee, ich sehe schon ihr seht auch nicht den Fehler, man